// $ANTLR 3.4 D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g 2012-12-17 10:38:52

package newcrunch.lexers;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

import org.antlr.runtime.tree.*;


/** A Java 1.5 grammar for ANTLR v3 derived from the spec
 *
 *  This is a very close representation of the spec; the changes
 *  are comestic (remove left recursion) and also fixes (the spec
 *  isn't exactly perfect).  I have run this on the 1.4.2 source
 *  and some nasty looking enums from 1.5, but have not really
 *  tested for 1.5 compatibility.
 *
 *  I built this with: java -Xmx100M org.antlr.Tool java.g
 *  and got two errors that are ok (for now):
 *  java.g:691:9: Decision can match input such as
 *    "'0'..'9'{'E', 'e'}{'+', '-'}'0'..'9'{'D', 'F', 'd', 'f'}"
 *    using multiple alternatives: 3, 4
 *  As a result, alternative(s) 4 were disabled for that input
 *  java.g:734:35: Decision can match input such as "{'$', 'A'..'Z',
 *    '_', 'a'..'z', '\u00C0'..'\u00D6', '\u00D8'..'\u00F6',
 *    '\u00F8'..'\u1FFF', '\u3040'..'\u318F', '\u3300'..'\u337F',
 *    '\u3400'..'\u3D2D', '\u4E00'..'\u9FFF', '\uF900'..'\uFAFF'}"
 *    using multiple alternatives: 1, 2
 *  As a result, alternative(s) 2 were disabled for that input
 *
 *  You can turn enum on/off as a keyword :)
 *
 *  Version 1.0 -- initial release July 5, 2006 (requires 3.0b2 or higher)
 *
 *  Primary author: Terence Parr, July 2006
 *
 *  Version 1.0.1 -- corrections by Koen Vanderkimpen & Marko van Dooren,
 *      October 25, 2006;
 *      fixed normalInterfaceDeclaration: now uses typeParameters instead
 *          of typeParameter (according to JLS, 3rd edition)
 *      fixed castExpression: no longer allows expression next to type
 *          (according to semantics in JLS, in contrast with syntax in JLS)
 *
 *  Version 1.0.2 -- Terence Parr, Nov 27, 2006
 *      java spec I built this from had some bizarre for-loop control.
 *          Looked weird and so I looked elsewhere...Yep, it's messed up.
 *          simplified.
 *
 *  Version 1.0.3 -- Chris Hogue, Feb 26, 2007
 *      Factored out an annotationName rule and used it in the annotation rule.
 *          Not sure why, but typeName wasn't recognizing references to inner
 *          annotations (e.g. @InterfaceName.InnerAnnotation())
 *      Factored out the elementValue section of an annotation reference.  Created
 *          elementValuePair and elementValuePairs rules, then used them in the
 *          annotation rule.  Allows it to recognize annotation references with
 *          multiple, comma separated attributes.
 *      Updated elementValueArrayInitializer so that it allows multiple elements.
 *          (It was only allowing 0 or 1 element).
 *      Updated localVariableDeclaration to allow annotations.  Interestingly the JLS
 *          doesn't appear to indicate this is legal, but it does work as of at least
 *          JDK 1.5.0_06.
 *      Moved the Identifier portion of annotationTypeElementRest to annotationMethodRest.
 *          Because annotationConstantRest already references variableDeclarator which
 *          has the Identifier portion in it, the parser would fail on constants in
 *          annotation definitions because it expected two identifiers.
 *      Added optional trailing ';' to the alternatives in annotationTypeElementRest.
 *          Wouldn't handle an inner interface that has a trailing ';'.
 *      Swapped the expression and type rule reference order in castExpression to
 *          make it check for genericized casts first.  It was failing to recognize a
 *          statement like  "Class<Byte> TYPE = (Class<Byte>)...;" because it was seeing
 *          'Class<Byte' in the cast expression as a less than expression, then failing
 *          on the '>'.
 *      Changed createdName to use typeArguments instead of nonWildcardTypeArguments.
 *         
 *      Changed the 'this' alternative in primary to allow 'identifierSuffix' rather than
 *          just 'arguments'.  The case it couldn't handle was a call to an explicit
 *          generic method invocation (e.g. this.<E>doSomething()).  Using identifierSuffix
 *          may be overly aggressive--perhaps should create a more constrained thisSuffix rule?
 *
 *  Version 1.0.4 -- Hiroaki Nakamura, May 3, 2007
 *
 *  Fixed formalParameterDecls, localVariableDeclaration, forInit,
 *  and forVarControl to use variableModifier* not 'final'? (annotation)?
 *
 *  Version 1.0.5 -- Terence, June 21, 2007
 *  --a[i].foo didn't work. Fixed unaryExpression
 *
 *  Version 1.0.6 -- John Ridgway, March 17, 2008
 *      Made "assert" a switchable keyword like "enum".
 *      Fixed compilationUnit to disallow "annotation importDeclaration ...".
 *      Changed "Identifier ('.' Identifier)*" to "qualifiedName" in more
 *          places.
 *      Changed modifier* and/or variableModifier* to classOrInterfaceModifiers,
 *          modifiers or variableModifiers, as appropriate.
 *      Renamed "bound" to "typeBound" to better match language in the JLS.
 *      Added "memberDeclaration" which rewrites to methodDeclaration or
 *      fieldDeclaration and pulled type into memberDeclaration.  So we parse
 *          type and then move on to decide whether we're dealing with a field
 *          or a method.
 *      Modified "constructorDeclaration" to use "constructorBody" instead of
 *          "methodBody".  constructorBody starts with explicitConstructorInvocation,
 *          then goes on to blockStatement*.  Pulling explicitConstructorInvocation
 *          out of expressions allowed me to simplify "primary".
 *      Changed variableDeclarator to simplify it.
 *      Changed type to use classOrInterfaceType, thus simplifying it; of course
 *          I then had to add classOrInterfaceType, but it is used in several
 *          places.
 *      Fixed annotations, old version allowed "@X(y,z)", which is illegal.
 *      Added optional comma to end of "elementValueArrayInitializer"; as per JLS.
 *      Changed annotationTypeElementRest to use normalClassDeclaration and
 *          normalInterfaceDeclaration rather than classDeclaration and
 *          interfaceDeclaration, thus getting rid of a couple of grammar ambiguities.
 *      Split localVariableDeclaration into localVariableDeclarationStatement
 *          (includes the terminating semi-colon) and localVariableDeclaration.
 *          This allowed me to use localVariableDeclaration in "forInit" clauses,
 *           simplifying them.
 *      Changed switchBlockStatementGroup to use multiple labels.  This adds an
 *          ambiguity, but if one uses appropriately greedy parsing it yields the
 *           parse that is closest to the meaning of the switch statement.
 *      Renamed "forVarControl" to "enhancedForControl" -- JLS language.
 *      Added semantic predicates to test for shift operations rather than other
 *          things.  Thus, for instance, the string "< <" will never be treated
 *          as a left-shift operator.
 *      In "creator" we rule out "nonWildcardTypeArguments" on arrayCreation,
 *          which are illegal.
 *      Moved "nonWildcardTypeArguments into innerCreator.
 *      Removed 'super' superSuffix from explicitGenericInvocation, since that
 *          is only used in explicitConstructorInvocation at the beginning of a
 *           constructorBody.  (This is part of the simplification of expressions
 *           mentioned earlier.)
 *      Simplified primary (got rid of those things that are only used in
 *          explicitConstructorInvocation).
 *      Lexer -- removed "Exponent?" from FloatingPointLiteral choice 4, since it
 *          led to an ambiguity.
 *
 *      This grammar successfully parses every .java file in the JDK 1.5 source
 *          tree (excluding those whose file names include '-', which are not
 *          valid Java compilation units).
 *
 *  Known remaining problems:
 *      "Letter" and "JavaIDDigit" are wrong.  The actual specification of
 *      "Letter" should be "a character for which the method
 *      Character.isJavaIdentifierStart(int) returns true."  A "Java
 *      letter-or-digit is a character for which the method
 *      Character.isJavaIdentifierPart(int) returns true."
 */
@SuppressWarnings({"all", "warnings", "unchecked"})
public class JavaTreeParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ABSTRACT", "AMP", "AMPAMP", "AMPEQ", "ANNOTATION", "ANNOTATION_METHOD", "ASSERT", "BANG", "BANGEQ", "BAR", "BARBAR", "BAREQ", "BOOLEAN", "BREAK", "BYTE", "BinDigit", "BinPrefix", "CARET", "CARETEQ", "CASE", "CATCH", "CHAR", "CHARLITERAL", "CLASS", "CLASSBODY", "COLON", "COMMA", "COMMENT", "CONST", "CONTINUE", "DEFAULT", "DO", "DOT", "DOUBLE", "DOUBLELITERAL", "DecDigits", "DoubleSuffix", "ELLIPSIS", "ELLIPSIS_PARA", "ELSE", "ENUM", "ENUM_CONST", "ENUM_DECL", "EQ", "EQEQ", "EXTENDS", "EscapeSequence", "Exponent", "FALSE", "FIELD", "FINAL", "FINALLY", "FLOAT", "FLOATLITERAL", "FOR", "FloatSuffix", "GENERICS", "GOTO", "GT", "HexDigit", "HexDigits", "HexPrefix", "IDENTIFIER", "IF", "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "INTLITERAL", "IdentifierPart", "IdentifierStart", "IntegerNumber", "LBRACE", "LBRACKET", "LINE_COMMENT", "LONG", "LONGLITERAL", "LPAREN", "LT", "LongSuffix", "METHOD", "MODIFIER", "MONKEYS_AT", "NAME", "NATIVE", "NEW", "NORMAL_PARA", "NULL", "NonIntegerNumber", "PACKAGE", "PARA", "PERCENT", "PERCENTEQ", "PLUS", "PLUSEQ", "PLUSPLUS", "PRIVATE", "PROTECTED", "PUBLIC", "QUES", "RBRACE", "RBRACKET", "RETURN", "ROOT", "RPAREN", "SEMI", "SHORT", "SLASH", "SLASHEQ", "STAR", "STAREQ", "STATIC", "STRICTFP", "STRINGLITERAL", "SUB", "SUBEQ", "SUBSUB", "SUPER", "SWITCH", "SYNCHRONIZED", "SurrogateIdentifer", "THIS", "THROW", "THROWS", "TILDE", "TRANSIENT", "TRUE", "TRY", "TYPE", "TYPE_ARG", "VARIABLE", "VOID", "VOLATILE", "WHILE", "WS"
    };

    public static final int EOF=-1;
    public static final int ABSTRACT=4;
    public static final int AMP=5;
    public static final int AMPAMP=6;
    public static final int AMPEQ=7;
    public static final int ANNOTATION=8;
    public static final int ANNOTATION_METHOD=9;
    public static final int ASSERT=10;
    public static final int BANG=11;
    public static final int BANGEQ=12;
    public static final int BAR=13;
    public static final int BARBAR=14;
    public static final int BAREQ=15;
    public static final int BOOLEAN=16;
    public static final int BREAK=17;
    public static final int BYTE=18;
    public static final int BinDigit=19;
    public static final int BinPrefix=20;
    public static final int CARET=21;
    public static final int CARETEQ=22;
    public static final int CASE=23;
    public static final int CATCH=24;
    public static final int CHAR=25;
    public static final int CHARLITERAL=26;
    public static final int CLASS=27;
    public static final int CLASSBODY=28;
    public static final int COLON=29;
    public static final int COMMA=30;
    public static final int COMMENT=31;
    public static final int CONST=32;
    public static final int CONTINUE=33;
    public static final int DEFAULT=34;
    public static final int DO=35;
    public static final int DOT=36;
    public static final int DOUBLE=37;
    public static final int DOUBLELITERAL=38;
    public static final int DecDigits=39;
    public static final int DoubleSuffix=40;
    public static final int ELLIPSIS=41;
    public static final int ELLIPSIS_PARA=42;
    public static final int ELSE=43;
    public static final int ENUM=44;
    public static final int ENUM_CONST=45;
    public static final int ENUM_DECL=46;
    public static final int EQ=47;
    public static final int EQEQ=48;
    public static final int EXTENDS=49;
    public static final int EscapeSequence=50;
    public static final int Exponent=51;
    public static final int FALSE=52;
    public static final int FIELD=53;
    public static final int FINAL=54;
    public static final int FINALLY=55;
    public static final int FLOAT=56;
    public static final int FLOATLITERAL=57;
    public static final int FOR=58;
    public static final int FloatSuffix=59;
    public static final int GENERICS=60;
    public static final int GOTO=61;
    public static final int GT=62;
    public static final int HexDigit=63;
    public static final int HexDigits=64;
    public static final int HexPrefix=65;
    public static final int IDENTIFIER=66;
    public static final int IF=67;
    public static final int IMPLEMENTS=68;
    public static final int IMPORT=69;
    public static final int INSTANCEOF=70;
    public static final int INT=71;
    public static final int INTERFACE=72;
    public static final int INTLITERAL=73;
    public static final int IdentifierPart=74;
    public static final int IdentifierStart=75;
    public static final int IntegerNumber=76;
    public static final int LBRACE=77;
    public static final int LBRACKET=78;
    public static final int LINE_COMMENT=79;
    public static final int LONG=80;
    public static final int LONGLITERAL=81;
    public static final int LPAREN=82;
    public static final int LT=83;
    public static final int LongSuffix=84;
    public static final int METHOD=85;
    public static final int MODIFIER=86;
    public static final int MONKEYS_AT=87;
    public static final int NAME=88;
    public static final int NATIVE=89;
    public static final int NEW=90;
    public static final int NORMAL_PARA=91;
    public static final int NULL=92;
    public static final int NonIntegerNumber=93;
    public static final int PACKAGE=94;
    public static final int PARA=95;
    public static final int PERCENT=96;
    public static final int PERCENTEQ=97;
    public static final int PLUS=98;
    public static final int PLUSEQ=99;
    public static final int PLUSPLUS=100;
    public static final int PRIVATE=101;
    public static final int PROTECTED=102;
    public static final int PUBLIC=103;
    public static final int QUES=104;
    public static final int RBRACE=105;
    public static final int RBRACKET=106;
    public static final int RETURN=107;
    public static final int ROOT=108;
    public static final int RPAREN=109;
    public static final int SEMI=110;
    public static final int SHORT=111;
    public static final int SLASH=112;
    public static final int SLASHEQ=113;
    public static final int STAR=114;
    public static final int STAREQ=115;
    public static final int STATIC=116;
    public static final int STRICTFP=117;
    public static final int STRINGLITERAL=118;
    public static final int SUB=119;
    public static final int SUBEQ=120;
    public static final int SUBSUB=121;
    public static final int SUPER=122;
    public static final int SWITCH=123;
    public static final int SYNCHRONIZED=124;
    public static final int SurrogateIdentifer=125;
    public static final int THIS=126;
    public static final int THROW=127;
    public static final int THROWS=128;
    public static final int TILDE=129;
    public static final int TRANSIENT=130;
    public static final int TRUE=131;
    public static final int TRY=132;
    public static final int TYPE=133;
    public static final int TYPE_ARG=134;
    public static final int VARIABLE=135;
    public static final int VOID=136;
    public static final int VOLATILE=137;
    public static final int WHILE=138;
    public static final int WS=139;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public JavaTreeParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public JavaTreeParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
        this.state.ruleMemo = new HashMap[400+1];
         

    }

protected TreeAdaptor adaptor = new CommonTreeAdaptor();

public void setTreeAdaptor(TreeAdaptor adaptor) {
    this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
    return adaptor;
}
    public String[] getTokenNames() { return JavaTreeParser.tokenNames; }
    public String getGrammarFileName() { return "D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g"; }


    //silences the spewing of errors on the console.
    public void emitErrorMessage(String msg) {}


    public static class compilationUnit_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "compilationUnit"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:313:1: compilationUnit : ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* -> ^( ROOT ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* ) ;
    public final JavaTreeParser.compilationUnit_return compilationUnit() throws RecognitionException {
        JavaTreeParser.compilationUnit_return retval = new JavaTreeParser.compilationUnit_return();
        retval.start = input.LT(1);

        int compilationUnit_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.annotations_return annotations1 =null;

        JavaTreeParser.packageDeclaration_return packageDeclaration2 =null;

        JavaTreeParser.importDeclaration_return importDeclaration3 =null;

        JavaTreeParser.typeDeclaration_return typeDeclaration4 =null;


        RewriteRuleSubtreeStream stream_packageDeclaration=new RewriteRuleSubtreeStream(adaptor,"rule packageDeclaration");
        RewriteRuleSubtreeStream stream_annotations=new RewriteRuleSubtreeStream(adaptor,"rule annotations");
        RewriteRuleSubtreeStream stream_typeDeclaration=new RewriteRuleSubtreeStream(adaptor,"rule typeDeclaration");
        RewriteRuleSubtreeStream stream_importDeclaration=new RewriteRuleSubtreeStream(adaptor,"rule importDeclaration");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:5: ( ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* -> ^( ROOT ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* ) )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:9: ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )*
            {
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:9: ( ( annotations )? packageDeclaration )?
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==MONKEYS_AT) ) {
                int LA2_1 = input.LA(2);

                if ( (synpred2_JavaTree()) ) {
                    alt2=1;
                }
            }
            else if ( (LA2_0==PACKAGE) ) {
                alt2=1;
            }
            switch (alt2) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:10: ( annotations )? packageDeclaration
                    {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:10: ( annotations )?
                    int alt1=2;
                    int LA1_0 = input.LA(1);

                    if ( (LA1_0==MONKEYS_AT) ) {
                        alt1=1;
                    }
                    switch (alt1) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:11: annotations
                            {
                            pushFollow(FOLLOW_annotations_in_compilationUnit169);
                            annotations1=annotations();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_annotations.add(annotations1.getTree());

                            }
                            break;

                    }


                    pushFollow(FOLLOW_packageDeclaration_in_compilationUnit173);
                    packageDeclaration2=packageDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_packageDeclaration.add(packageDeclaration2.getTree());

                    }
                    break;

            }


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:46: ( importDeclaration )*
            loop3:
            do {
                int alt3=2;
                int LA3_0 = input.LA(1);

                if ( (LA3_0==IMPORT) ) {
                    alt3=1;
                }


                switch (alt3) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:47: importDeclaration
            	    {
            	    pushFollow(FOLLOW_importDeclaration_in_compilationUnit178);
            	    importDeclaration3=importDeclaration();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_importDeclaration.add(importDeclaration3.getTree());

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:67: ( typeDeclaration )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0==ABSTRACT||LA4_0==BOOLEAN||LA4_0==BYTE||LA4_0==CHAR||LA4_0==CLASS||LA4_0==DOUBLE||LA4_0==ENUM||LA4_0==FINAL||LA4_0==FLOAT||LA4_0==IDENTIFIER||(LA4_0 >= INT && LA4_0 <= INTERFACE)||LA4_0==LONG||LA4_0==LT||LA4_0==MONKEYS_AT||LA4_0==NATIVE||(LA4_0 >= PRIVATE && LA4_0 <= PUBLIC)||(LA4_0 >= SEMI && LA4_0 <= SHORT)||(LA4_0 >= STATIC && LA4_0 <= STRICTFP)||LA4_0==SYNCHRONIZED||LA4_0==TRANSIENT||(LA4_0 >= VOID && LA4_0 <= VOLATILE)) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:68: typeDeclaration
            	    {
            	    pushFollow(FOLLOW_typeDeclaration_in_compilationUnit183);
            	    typeDeclaration4=typeDeclaration();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_typeDeclaration.add(typeDeclaration4.getTree());

            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);


            // AST REWRITE
            // elements: importDeclaration, annotations, packageDeclaration, typeDeclaration
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 314:86: -> ^( ROOT ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* )
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:315:6: ^( ROOT ( ( annotations )? packageDeclaration )? ( importDeclaration )* ( typeDeclaration )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(ROOT, "ROOT")
                , root_1);

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:315:13: ( ( annotations )? packageDeclaration )?
                if ( stream_annotations.hasNext()||stream_packageDeclaration.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:315:14: ( annotations )?
                    if ( stream_annotations.hasNext() ) {
                        adaptor.addChild(root_1, stream_annotations.nextTree());

                    }
                    stream_annotations.reset();

                    adaptor.addChild(root_1, stream_packageDeclaration.nextTree());

                }
                stream_annotations.reset();
                stream_packageDeclaration.reset();

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:315:50: ( importDeclaration )*
                while ( stream_importDeclaration.hasNext() ) {
                    adaptor.addChild(root_1, stream_importDeclaration.nextTree());

                }
                stream_importDeclaration.reset();

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:315:71: ( typeDeclaration )*
                while ( stream_typeDeclaration.hasNext() ) {
                    adaptor.addChild(root_1, stream_typeDeclaration.nextTree());

                }
                stream_typeDeclaration.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 1, compilationUnit_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "compilationUnit"


    public static class packageDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "packageDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:318:1: packageDeclaration : 'package' qualifiedName ';' ;
    public final JavaTreeParser.packageDeclaration_return packageDeclaration() throws RecognitionException {
        JavaTreeParser.packageDeclaration_return retval = new JavaTreeParser.packageDeclaration_return();
        retval.start = input.LT(1);

        int packageDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal5=null;
        Token char_literal7=null;
        JavaTreeParser.qualifiedName_return qualifiedName6 =null;


        Object string_literal5_tree=null;
        Object char_literal7_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:319:5: ( 'package' qualifiedName ';' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:319:9: 'package' qualifiedName ';'
            {
            root_0 = (Object)adaptor.nil();


            string_literal5=(Token)match(input,PACKAGE,FOLLOW_PACKAGE_in_packageDeclaration237); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            string_literal5_tree = 
            (Object)adaptor.create(string_literal5)
            ;
            adaptor.addChild(root_0, string_literal5_tree);
            }

            pushFollow(FOLLOW_qualifiedName_in_packageDeclaration239);
            qualifiedName6=qualifiedName();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, qualifiedName6.getTree());

            char_literal7=(Token)match(input,SEMI,FOLLOW_SEMI_in_packageDeclaration241); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal7_tree = 
            (Object)adaptor.create(char_literal7)
            ;
            adaptor.addChild(root_0, char_literal7_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 2, packageDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "packageDeclaration"


    public static class importDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "importDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:322:1: importDeclaration : ( 'import' ( 'static' )? IDENTIFIER '.' '*' ';' | 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';' );
    public final JavaTreeParser.importDeclaration_return importDeclaration() throws RecognitionException {
        JavaTreeParser.importDeclaration_return retval = new JavaTreeParser.importDeclaration_return();
        retval.start = input.LT(1);

        int importDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal8=null;
        Token string_literal9=null;
        Token IDENTIFIER10=null;
        Token char_literal11=null;
        Token char_literal12=null;
        Token char_literal13=null;
        Token string_literal14=null;
        Token string_literal15=null;
        Token IDENTIFIER16=null;
        Token char_literal17=null;
        Token IDENTIFIER18=null;
        Token char_literal19=null;
        Token char_literal20=null;
        Token char_literal21=null;

        Object string_literal8_tree=null;
        Object string_literal9_tree=null;
        Object IDENTIFIER10_tree=null;
        Object char_literal11_tree=null;
        Object char_literal12_tree=null;
        Object char_literal13_tree=null;
        Object string_literal14_tree=null;
        Object string_literal15_tree=null;
        Object IDENTIFIER16_tree=null;
        Object char_literal17_tree=null;
        Object IDENTIFIER18_tree=null;
        Object char_literal19_tree=null;
        Object char_literal20_tree=null;
        Object char_literal21_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:323:5: ( 'import' ( 'static' )? IDENTIFIER '.' '*' ';' | 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';' )
            int alt9=2;
            int LA9_0 = input.LA(1);

            if ( (LA9_0==IMPORT) ) {
                int LA9_1 = input.LA(2);

                if ( (LA9_1==STATIC) ) {
                    int LA9_2 = input.LA(3);

                    if ( (LA9_2==IDENTIFIER) ) {
                        int LA9_3 = input.LA(4);

                        if ( (LA9_3==DOT) ) {
                            int LA9_4 = input.LA(5);

                            if ( (LA9_4==STAR) ) {
                                alt9=1;
                            }
                            else if ( (LA9_4==IDENTIFIER) ) {
                                alt9=2;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return retval;}
                                NoViableAltException nvae =
                                    new NoViableAltException("", 9, 4, input);

                                throw nvae;

                            }
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return retval;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 9, 3, input);

                            throw nvae;

                        }
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 9, 2, input);

                        throw nvae;

                    }
                }
                else if ( (LA9_1==IDENTIFIER) ) {
                    int LA9_3 = input.LA(3);

                    if ( (LA9_3==DOT) ) {
                        int LA9_4 = input.LA(4);

                        if ( (LA9_4==STAR) ) {
                            alt9=1;
                        }
                        else if ( (LA9_4==IDENTIFIER) ) {
                            alt9=2;
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return retval;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 9, 4, input);

                            throw nvae;

                        }
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 9, 3, input);

                        throw nvae;

                    }
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 9, 1, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;

            }
            switch (alt9) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:323:9: 'import' ( 'static' )? IDENTIFIER '.' '*' ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal8=(Token)match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration263); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal8_tree = 
                    (Object)adaptor.create(string_literal8)
                    ;
                    adaptor.addChild(root_0, string_literal8_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:324:9: ( 'static' )?
                    int alt5=2;
                    int LA5_0 = input.LA(1);

                    if ( (LA5_0==STATIC) ) {
                        alt5=1;
                    }
                    switch (alt5) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:324:10: 'static'
                            {
                            string_literal9=(Token)match(input,STATIC,FOLLOW_STATIC_in_importDeclaration275); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            string_literal9_tree = 
                            (Object)adaptor.create(string_literal9)
                            ;
                            adaptor.addChild(root_0, string_literal9_tree);
                            }

                            }
                            break;

                    }


                    IDENTIFIER10=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration296); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER10_tree = 
                    (Object)adaptor.create(IDENTIFIER10)
                    ;
                    adaptor.addChild(root_0, IDENTIFIER10_tree);
                    }

                    char_literal11=(Token)match(input,DOT,FOLLOW_DOT_in_importDeclaration298); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal11_tree = 
                    (Object)adaptor.create(char_literal11)
                    ;
                    adaptor.addChild(root_0, char_literal11_tree);
                    }

                    char_literal12=(Token)match(input,STAR,FOLLOW_STAR_in_importDeclaration300); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal12_tree = 
                    (Object)adaptor.create(char_literal12)
                    ;
                    adaptor.addChild(root_0, char_literal12_tree);
                    }

                    char_literal13=(Token)match(input,SEMI,FOLLOW_SEMI_in_importDeclaration310); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal13_tree = 
                    (Object)adaptor.create(char_literal13)
                    ;
                    adaptor.addChild(root_0, char_literal13_tree);
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:328:9: 'import' ( 'static' )? IDENTIFIER ( '.' IDENTIFIER )+ ( '.' '*' )? ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal14=(Token)match(input,IMPORT,FOLLOW_IMPORT_in_importDeclaration327); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal14_tree = 
                    (Object)adaptor.create(string_literal14)
                    ;
                    adaptor.addChild(root_0, string_literal14_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:329:9: ( 'static' )?
                    int alt6=2;
                    int LA6_0 = input.LA(1);

                    if ( (LA6_0==STATIC) ) {
                        alt6=1;
                    }
                    switch (alt6) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:329:10: 'static'
                            {
                            string_literal15=(Token)match(input,STATIC,FOLLOW_STATIC_in_importDeclaration339); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            string_literal15_tree = 
                            (Object)adaptor.create(string_literal15)
                            ;
                            adaptor.addChild(root_0, string_literal15_tree);
                            }

                            }
                            break;

                    }


                    IDENTIFIER16=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration360); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER16_tree = 
                    (Object)adaptor.create(IDENTIFIER16)
                    ;
                    adaptor.addChild(root_0, IDENTIFIER16_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:332:9: ( '.' IDENTIFIER )+
                    int cnt7=0;
                    loop7:
                    do {
                        int alt7=2;
                        int LA7_0 = input.LA(1);

                        if ( (LA7_0==DOT) ) {
                            int LA7_1 = input.LA(2);

                            if ( (LA7_1==IDENTIFIER) ) {
                                alt7=1;
                            }


                        }


                        switch (alt7) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:332:10: '.' IDENTIFIER
                    	    {
                    	    char_literal17=(Token)match(input,DOT,FOLLOW_DOT_in_importDeclaration371); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal17_tree = 
                    	    (Object)adaptor.create(char_literal17)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal17_tree);
                    	    }

                    	    IDENTIFIER18=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_importDeclaration373); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    IDENTIFIER18_tree = 
                    	    (Object)adaptor.create(IDENTIFIER18)
                    	    ;
                    	    adaptor.addChild(root_0, IDENTIFIER18_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt7 >= 1 ) break loop7;
                    	    if (state.backtracking>0) {state.failed=true; return retval;}
                                EarlyExitException eee =
                                    new EarlyExitException(7, input);
                                throw eee;
                        }
                        cnt7++;
                    } while (true);


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:334:9: ( '.' '*' )?
                    int alt8=2;
                    int LA8_0 = input.LA(1);

                    if ( (LA8_0==DOT) ) {
                        alt8=1;
                    }
                    switch (alt8) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:334:10: '.' '*'
                            {
                            char_literal19=(Token)match(input,DOT,FOLLOW_DOT_in_importDeclaration395); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            char_literal19_tree = 
                            (Object)adaptor.create(char_literal19)
                            ;
                            adaptor.addChild(root_0, char_literal19_tree);
                            }

                            char_literal20=(Token)match(input,STAR,FOLLOW_STAR_in_importDeclaration397); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            char_literal20_tree = 
                            (Object)adaptor.create(char_literal20)
                            ;
                            adaptor.addChild(root_0, char_literal20_tree);
                            }

                            }
                            break;

                    }


                    char_literal21=(Token)match(input,SEMI,FOLLOW_SEMI_in_importDeclaration418); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal21_tree = 
                    (Object)adaptor.create(char_literal21)
                    ;
                    adaptor.addChild(root_0, char_literal21_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 3, importDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "importDeclaration"


    public static class qualifiedImportName_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "qualifiedImportName"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:339:1: qualifiedImportName : IDENTIFIER ( '.' IDENTIFIER )* ;
    public final JavaTreeParser.qualifiedImportName_return qualifiedImportName() throws RecognitionException {
        JavaTreeParser.qualifiedImportName_return retval = new JavaTreeParser.qualifiedImportName_return();
        retval.start = input.LT(1);

        int qualifiedImportName_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER22=null;
        Token char_literal23=null;
        Token IDENTIFIER24=null;

        Object IDENTIFIER22_tree=null;
        Object char_literal23_tree=null;
        Object IDENTIFIER24_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:340:5: ( IDENTIFIER ( '.' IDENTIFIER )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:340:9: IDENTIFIER ( '.' IDENTIFIER )*
            {
            root_0 = (Object)adaptor.nil();


            IDENTIFIER22=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedImportName438); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER22_tree = 
            (Object)adaptor.create(IDENTIFIER22)
            ;
            adaptor.addChild(root_0, IDENTIFIER22_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:341:9: ( '.' IDENTIFIER )*
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( (LA10_0==DOT) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:341:10: '.' IDENTIFIER
            	    {
            	    char_literal23=(Token)match(input,DOT,FOLLOW_DOT_in_qualifiedImportName449); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal23_tree = 
            	    (Object)adaptor.create(char_literal23)
            	    ;
            	    adaptor.addChild(root_0, char_literal23_tree);
            	    }

            	    IDENTIFIER24=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedImportName451); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    IDENTIFIER24_tree = 
            	    (Object)adaptor.create(IDENTIFIER24)
            	    ;
            	    adaptor.addChild(root_0, IDENTIFIER24_tree);
            	    }

            	    }
            	    break;

            	default :
            	    break loop10;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 4, qualifiedImportName_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "qualifiedImportName"


    public static class typeDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "typeDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:345:1: typeDeclaration : ( classOrInterfaceDeclaration | ';' );
    public final JavaTreeParser.typeDeclaration_return typeDeclaration() throws RecognitionException {
        JavaTreeParser.typeDeclaration_return retval = new JavaTreeParser.typeDeclaration_return();
        retval.start = input.LT(1);

        int typeDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal26=null;
        JavaTreeParser.classOrInterfaceDeclaration_return classOrInterfaceDeclaration25 =null;


        Object char_literal26_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:346:5: ( classOrInterfaceDeclaration | ';' )
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( (LA11_0==ABSTRACT||LA11_0==BOOLEAN||LA11_0==BYTE||LA11_0==CHAR||LA11_0==CLASS||LA11_0==DOUBLE||LA11_0==ENUM||LA11_0==FINAL||LA11_0==FLOAT||LA11_0==IDENTIFIER||(LA11_0 >= INT && LA11_0 <= INTERFACE)||LA11_0==LONG||LA11_0==LT||LA11_0==MONKEYS_AT||LA11_0==NATIVE||(LA11_0 >= PRIVATE && LA11_0 <= PUBLIC)||LA11_0==SHORT||(LA11_0 >= STATIC && LA11_0 <= STRICTFP)||LA11_0==SYNCHRONIZED||LA11_0==TRANSIENT||(LA11_0 >= VOID && LA11_0 <= VOLATILE)) ) {
                alt11=1;
            }
            else if ( (LA11_0==SEMI) ) {
                alt11=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;

            }
            switch (alt11) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:346:9: classOrInterfaceDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_classOrInterfaceDeclaration_in_typeDeclaration482);
                    classOrInterfaceDeclaration25=classOrInterfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, classOrInterfaceDeclaration25.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:347:9: ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal26=(Token)match(input,SEMI,FOLLOW_SEMI_in_typeDeclaration492); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal26_tree = 
                    (Object)adaptor.create(char_literal26)
                    ;
                    adaptor.addChild(root_0, char_literal26_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 5, typeDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "typeDeclaration"


    public static class classOrInterfaceDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "classOrInterfaceDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:350:1: classOrInterfaceDeclaration : ( classDeclaration | interfaceDeclaration );
    public final JavaTreeParser.classOrInterfaceDeclaration_return classOrInterfaceDeclaration() throws RecognitionException {
        JavaTreeParser.classOrInterfaceDeclaration_return retval = new JavaTreeParser.classOrInterfaceDeclaration_return();
        retval.start = input.LT(1);

        int classOrInterfaceDeclaration_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.classDeclaration_return classDeclaration27 =null;

        JavaTreeParser.interfaceDeclaration_return interfaceDeclaration28 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:351:5: ( classDeclaration | interfaceDeclaration )
            int alt12=2;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA12_1 = input.LA(2);

                if ( (synpred12_JavaTree()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA12_2 = input.LA(2);

                if ( (synpred12_JavaTree()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA12_3 = input.LA(2);

                if ( (synpred12_JavaTree()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA12_4 = input.LA(2);

                if ( (synpred12_JavaTree()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA12_5 = input.LA(2);

                if ( (synpred12_JavaTree()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA12_6 = input.LA(2);

                if ( (synpred12_JavaTree()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA12_7 = input.LA(2);

                if ( (synpred12_JavaTree()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA12_8 = input.LA(2);

                if ( (synpred12_JavaTree()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA12_9 = input.LA(2);

                if ( (synpred12_JavaTree()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA12_10 = input.LA(2);

                if ( (synpred12_JavaTree()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA12_11 = input.LA(2);

                if ( (synpred12_JavaTree()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA12_12 = input.LA(2);

                if ( (synpred12_JavaTree()) ) {
                    alt12=1;
                }
                else if ( (true) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 12, input);

                    throw nvae;

                }
                }
                break;
            case CLASS:
            case ENUM:
                {
                alt12=1;
                }
                break;
            case INTERFACE:
                {
                alt12=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;

            }

            switch (alt12) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:351:10: classDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_classDeclaration_in_classOrInterfaceDeclaration513);
                    classDeclaration27=classDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, classDeclaration27.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:352:9: interfaceDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_interfaceDeclaration_in_classOrInterfaceDeclaration523);
                    interfaceDeclaration28=interfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, interfaceDeclaration28.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 6, classOrInterfaceDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "classOrInterfaceDeclaration"


    public static class modifiers_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "modifiers"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:356:1: modifiers : ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* ;
    public final JavaTreeParser.modifiers_return modifiers() throws RecognitionException {
        JavaTreeParser.modifiers_return retval = new JavaTreeParser.modifiers_return();
        retval.start = input.LT(1);

        int modifiers_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal30=null;
        Token string_literal31=null;
        Token string_literal32=null;
        Token string_literal33=null;
        Token string_literal34=null;
        Token string_literal35=null;
        Token string_literal36=null;
        Token string_literal37=null;
        Token string_literal38=null;
        Token string_literal39=null;
        Token string_literal40=null;
        JavaTreeParser.annotation_return annotation29 =null;


        Object string_literal30_tree=null;
        Object string_literal31_tree=null;
        Object string_literal32_tree=null;
        Object string_literal33_tree=null;
        Object string_literal34_tree=null;
        Object string_literal35_tree=null;
        Object string_literal36_tree=null;
        Object string_literal37_tree=null;
        Object string_literal38_tree=null;
        Object string_literal39_tree=null;
        Object string_literal40_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:357:5: ( ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:358:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )*
            {
            root_0 = (Object)adaptor.nil();


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:358:5: ( annotation | 'public' | 'protected' | 'private' | 'static' | 'abstract' | 'final' | 'native' | 'synchronized' | 'transient' | 'volatile' | 'strictfp' )*
            loop13:
            do {
                int alt13=13;
                switch ( input.LA(1) ) {
                case MONKEYS_AT:
                    {
                    int LA13_2 = input.LA(2);

                    if ( (LA13_2==IDENTIFIER) ) {
                        alt13=1;
                    }


                    }
                    break;
                case PUBLIC:
                    {
                    alt13=2;
                    }
                    break;
                case PROTECTED:
                    {
                    alt13=3;
                    }
                    break;
                case PRIVATE:
                    {
                    alt13=4;
                    }
                    break;
                case STATIC:
                    {
                    alt13=5;
                    }
                    break;
                case ABSTRACT:
                    {
                    alt13=6;
                    }
                    break;
                case FINAL:
                    {
                    alt13=7;
                    }
                    break;
                case NATIVE:
                    {
                    alt13=8;
                    }
                    break;
                case SYNCHRONIZED:
                    {
                    alt13=9;
                    }
                    break;
                case TRANSIENT:
                    {
                    alt13=10;
                    }
                    break;
                case VOLATILE:
                    {
                    alt13=11;
                    }
                    break;
                case STRICTFP:
                    {
                    alt13=12;
                    }
                    break;

                }

                switch (alt13) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:358:9: annotation
            	    {
            	    pushFollow(FOLLOW_annotation_in_modifiers557);
            	    annotation29=annotation();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, annotation29.getTree());

            	    }
            	    break;
            	case 2 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:359:9: 'public'
            	    {
            	    string_literal30=(Token)match(input,PUBLIC,FOLLOW_PUBLIC_in_modifiers567); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal30_tree = 
            	    (Object)adaptor.create(string_literal30)
            	    ;
            	    adaptor.addChild(root_0, string_literal30_tree);
            	    }

            	    }
            	    break;
            	case 3 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:360:9: 'protected'
            	    {
            	    string_literal31=(Token)match(input,PROTECTED,FOLLOW_PROTECTED_in_modifiers577); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal31_tree = 
            	    (Object)adaptor.create(string_literal31)
            	    ;
            	    adaptor.addChild(root_0, string_literal31_tree);
            	    }

            	    }
            	    break;
            	case 4 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:361:9: 'private'
            	    {
            	    string_literal32=(Token)match(input,PRIVATE,FOLLOW_PRIVATE_in_modifiers587); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal32_tree = 
            	    (Object)adaptor.create(string_literal32)
            	    ;
            	    adaptor.addChild(root_0, string_literal32_tree);
            	    }

            	    }
            	    break;
            	case 5 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:362:9: 'static'
            	    {
            	    string_literal33=(Token)match(input,STATIC,FOLLOW_STATIC_in_modifiers597); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal33_tree = 
            	    (Object)adaptor.create(string_literal33)
            	    ;
            	    adaptor.addChild(root_0, string_literal33_tree);
            	    }

            	    }
            	    break;
            	case 6 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:363:9: 'abstract'
            	    {
            	    string_literal34=(Token)match(input,ABSTRACT,FOLLOW_ABSTRACT_in_modifiers607); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal34_tree = 
            	    (Object)adaptor.create(string_literal34)
            	    ;
            	    adaptor.addChild(root_0, string_literal34_tree);
            	    }

            	    }
            	    break;
            	case 7 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:364:9: 'final'
            	    {
            	    string_literal35=(Token)match(input,FINAL,FOLLOW_FINAL_in_modifiers617); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal35_tree = 
            	    (Object)adaptor.create(string_literal35)
            	    ;
            	    adaptor.addChild(root_0, string_literal35_tree);
            	    }

            	    }
            	    break;
            	case 8 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:365:9: 'native'
            	    {
            	    string_literal36=(Token)match(input,NATIVE,FOLLOW_NATIVE_in_modifiers627); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal36_tree = 
            	    (Object)adaptor.create(string_literal36)
            	    ;
            	    adaptor.addChild(root_0, string_literal36_tree);
            	    }

            	    }
            	    break;
            	case 9 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:366:9: 'synchronized'
            	    {
            	    string_literal37=(Token)match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_modifiers637); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal37_tree = 
            	    (Object)adaptor.create(string_literal37)
            	    ;
            	    adaptor.addChild(root_0, string_literal37_tree);
            	    }

            	    }
            	    break;
            	case 10 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:367:9: 'transient'
            	    {
            	    string_literal38=(Token)match(input,TRANSIENT,FOLLOW_TRANSIENT_in_modifiers647); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal38_tree = 
            	    (Object)adaptor.create(string_literal38)
            	    ;
            	    adaptor.addChild(root_0, string_literal38_tree);
            	    }

            	    }
            	    break;
            	case 11 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:368:9: 'volatile'
            	    {
            	    string_literal39=(Token)match(input,VOLATILE,FOLLOW_VOLATILE_in_modifiers657); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal39_tree = 
            	    (Object)adaptor.create(string_literal39)
            	    ;
            	    adaptor.addChild(root_0, string_literal39_tree);
            	    }

            	    }
            	    break;
            	case 12 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:369:9: 'strictfp'
            	    {
            	    string_literal40=(Token)match(input,STRICTFP,FOLLOW_STRICTFP_in_modifiers667); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal40_tree = 
            	    (Object)adaptor.create(string_literal40)
            	    ;
            	    adaptor.addChild(root_0, string_literal40_tree);
            	    }

            	    }
            	    break;

            	default :
            	    break loop13;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 7, modifiers_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "modifiers"


    public static class variableModifiers_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "variableModifiers"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:374:1: variableModifiers : ( 'final' | annotation )* ;
    public final JavaTreeParser.variableModifiers_return variableModifiers() throws RecognitionException {
        JavaTreeParser.variableModifiers_return retval = new JavaTreeParser.variableModifiers_return();
        retval.start = input.LT(1);

        int variableModifiers_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal41=null;
        JavaTreeParser.annotation_return annotation42 =null;


        Object string_literal41_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:375:5: ( ( 'final' | annotation )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:375:9: ( 'final' | annotation )*
            {
            root_0 = (Object)adaptor.nil();


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:375:9: ( 'final' | annotation )*
            loop14:
            do {
                int alt14=3;
                int LA14_0 = input.LA(1);

                if ( (LA14_0==FINAL) ) {
                    alt14=1;
                }
                else if ( (LA14_0==MONKEYS_AT) ) {
                    alt14=2;
                }


                switch (alt14) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:375:13: 'final'
            	    {
            	    string_literal41=(Token)match(input,FINAL,FOLLOW_FINAL_in_variableModifiers699); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal41_tree = 
            	    (Object)adaptor.create(string_literal41)
            	    ;
            	    adaptor.addChild(root_0, string_literal41_tree);
            	    }

            	    }
            	    break;
            	case 2 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:376:13: annotation
            	    {
            	    pushFollow(FOLLOW_annotation_in_variableModifiers713);
            	    annotation42=annotation();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, annotation42.getTree());

            	    }
            	    break;

            	default :
            	    break loop14;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 8, variableModifiers_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "variableModifiers"


    public static class classDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "classDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:381:1: classDeclaration : ( normalClassDeclaration | enumDeclaration );
    public final JavaTreeParser.classDeclaration_return classDeclaration() throws RecognitionException {
        JavaTreeParser.classDeclaration_return retval = new JavaTreeParser.classDeclaration_return();
        retval.start = input.LT(1);

        int classDeclaration_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.normalClassDeclaration_return normalClassDeclaration43 =null;

        JavaTreeParser.enumDeclaration_return enumDeclaration44 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:382:5: ( normalClassDeclaration | enumDeclaration )
            int alt15=2;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA15_1 = input.LA(2);

                if ( (synpred27_JavaTree()) ) {
                    alt15=1;
                }
                else if ( (true) ) {
                    alt15=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA15_2 = input.LA(2);

                if ( (synpred27_JavaTree()) ) {
                    alt15=1;
                }
                else if ( (true) ) {
                    alt15=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA15_3 = input.LA(2);

                if ( (synpred27_JavaTree()) ) {
                    alt15=1;
                }
                else if ( (true) ) {
                    alt15=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA15_4 = input.LA(2);

                if ( (synpred27_JavaTree()) ) {
                    alt15=1;
                }
                else if ( (true) ) {
                    alt15=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA15_5 = input.LA(2);

                if ( (synpred27_JavaTree()) ) {
                    alt15=1;
                }
                else if ( (true) ) {
                    alt15=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA15_6 = input.LA(2);

                if ( (synpred27_JavaTree()) ) {
                    alt15=1;
                }
                else if ( (true) ) {
                    alt15=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA15_7 = input.LA(2);

                if ( (synpred27_JavaTree()) ) {
                    alt15=1;
                }
                else if ( (true) ) {
                    alt15=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA15_8 = input.LA(2);

                if ( (synpred27_JavaTree()) ) {
                    alt15=1;
                }
                else if ( (true) ) {
                    alt15=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA15_9 = input.LA(2);

                if ( (synpred27_JavaTree()) ) {
                    alt15=1;
                }
                else if ( (true) ) {
                    alt15=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA15_10 = input.LA(2);

                if ( (synpred27_JavaTree()) ) {
                    alt15=1;
                }
                else if ( (true) ) {
                    alt15=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA15_11 = input.LA(2);

                if ( (synpred27_JavaTree()) ) {
                    alt15=1;
                }
                else if ( (true) ) {
                    alt15=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA15_12 = input.LA(2);

                if ( (synpred27_JavaTree()) ) {
                    alt15=1;
                }
                else if ( (true) ) {
                    alt15=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 15, 12, input);

                    throw nvae;

                }
                }
                break;
            case CLASS:
                {
                alt15=1;
                }
                break;
            case ENUM:
                {
                alt15=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 15, 0, input);

                throw nvae;

            }

            switch (alt15) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:382:9: normalClassDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_normalClassDeclaration_in_classDeclaration749);
                    normalClassDeclaration43=normalClassDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, normalClassDeclaration43.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:383:9: enumDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_enumDeclaration_in_classDeclaration759);
                    enumDeclaration44=enumDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, enumDeclaration44.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 9, classDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "classDeclaration"


    public static class normalClassDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "normalClassDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:386:1: normalClassDeclaration : modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody -> ^( CLASS IDENTIFIER ( modifiers )* ( ^( GENERICS typeParameters ) )? ( ^( EXTENDS type ) )? ( ^( IMPLEMENTS typeList ) )? ( classBody )* ) ;
    public final JavaTreeParser.normalClassDeclaration_return normalClassDeclaration() throws RecognitionException {
        JavaTreeParser.normalClassDeclaration_return retval = new JavaTreeParser.normalClassDeclaration_return();
        retval.start = input.LT(1);

        int normalClassDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal46=null;
        Token IDENTIFIER47=null;
        Token string_literal49=null;
        Token string_literal51=null;
        JavaTreeParser.modifiers_return modifiers45 =null;

        JavaTreeParser.typeParameters_return typeParameters48 =null;

        JavaTreeParser.type_return type50 =null;

        JavaTreeParser.typeList_return typeList52 =null;

        JavaTreeParser.classBody_return classBody53 =null;


        Object string_literal46_tree=null;
        Object IDENTIFIER47_tree=null;
        Object string_literal49_tree=null;
        Object string_literal51_tree=null;
        RewriteRuleTokenStream stream_CLASS=new RewriteRuleTokenStream(adaptor,"token CLASS");
        RewriteRuleTokenStream stream_IMPLEMENTS=new RewriteRuleTokenStream(adaptor,"token IMPLEMENTS");
        RewriteRuleTokenStream stream_EXTENDS=new RewriteRuleTokenStream(adaptor,"token EXTENDS");
        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
        RewriteRuleSubtreeStream stream_typeParameters=new RewriteRuleSubtreeStream(adaptor,"rule typeParameters");
        RewriteRuleSubtreeStream stream_classBody=new RewriteRuleSubtreeStream(adaptor,"rule classBody");
        RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
        RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
        RewriteRuleSubtreeStream stream_typeList=new RewriteRuleSubtreeStream(adaptor,"rule typeList");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:387:5: ( modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody -> ^( CLASS IDENTIFIER ( modifiers )* ( ^( GENERICS typeParameters ) )? ( ^( EXTENDS type ) )? ( ^( IMPLEMENTS typeList ) )? ( classBody )* ) )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:387:9: modifiers 'class' IDENTIFIER ( typeParameters )? ( 'extends' type )? ( 'implements' typeList )? classBody
            {
            pushFollow(FOLLOW_modifiers_in_normalClassDeclaration779);
            modifiers45=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_modifiers.add(modifiers45.getTree());

            string_literal46=(Token)match(input,CLASS,FOLLOW_CLASS_in_normalClassDeclaration782); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_CLASS.add(string_literal46);


            IDENTIFIER47=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalClassDeclaration784); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER47);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:388:9: ( typeParameters )?
            int alt16=2;
            int LA16_0 = input.LA(1);

            if ( (LA16_0==LT) ) {
                alt16=1;
            }
            switch (alt16) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:388:10: typeParameters
                    {
                    pushFollow(FOLLOW_typeParameters_in_normalClassDeclaration795);
                    typeParameters48=typeParameters();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_typeParameters.add(typeParameters48.getTree());

                    }
                    break;

            }


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:390:9: ( 'extends' type )?
            int alt17=2;
            int LA17_0 = input.LA(1);

            if ( (LA17_0==EXTENDS) ) {
                alt17=1;
            }
            switch (alt17) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:390:10: 'extends' type
                    {
                    string_literal49=(Token)match(input,EXTENDS,FOLLOW_EXTENDS_in_normalClassDeclaration817); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_EXTENDS.add(string_literal49);


                    pushFollow(FOLLOW_type_in_normalClassDeclaration819);
                    type50=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_type.add(type50.getTree());

                    }
                    break;

            }


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:392:9: ( 'implements' typeList )?
            int alt18=2;
            int LA18_0 = input.LA(1);

            if ( (LA18_0==IMPLEMENTS) ) {
                alt18=1;
            }
            switch (alt18) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:392:10: 'implements' typeList
                    {
                    string_literal51=(Token)match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_normalClassDeclaration841); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_IMPLEMENTS.add(string_literal51);


                    pushFollow(FOLLOW_typeList_in_normalClassDeclaration843);
                    typeList52=typeList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_typeList.add(typeList52.getTree());

                    }
                    break;

            }


            pushFollow(FOLLOW_classBody_in_normalClassDeclaration876);
            classBody53=classBody();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_classBody.add(classBody53.getTree());

            // AST REWRITE
            // elements: type, IDENTIFIER, typeList, typeParameters, modifiers, classBody
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 395:9: -> ^( CLASS IDENTIFIER ( modifiers )* ( ^( GENERICS typeParameters ) )? ( ^( EXTENDS type ) )? ( ^( IMPLEMENTS typeList ) )? ( classBody )* )
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:396:9: ^( CLASS IDENTIFIER ( modifiers )* ( ^( GENERICS typeParameters ) )? ( ^( EXTENDS type ) )? ( ^( IMPLEMENTS typeList ) )? ( classBody )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(CLASS, "CLASS")
                , root_1);

                adaptor.addChild(root_1, 
                stream_IDENTIFIER.nextNode()
                );

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:396:28: ( modifiers )*
                while ( stream_modifiers.hasNext() ) {
                    adaptor.addChild(root_1, stream_modifiers.nextTree());

                }
                stream_modifiers.reset();

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:397:17: ( ^( GENERICS typeParameters ) )?
                if ( stream_typeParameters.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:397:17: ^( GENERICS typeParameters )
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot(
                    (Object)adaptor.create(GENERICS, "GENERICS")
                    , root_2);

                    adaptor.addChild(root_2, stream_typeParameters.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_typeParameters.reset();

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:398:17: ( ^( EXTENDS type ) )?
                if ( stream_type.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:398:17: ^( EXTENDS type )
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot(
                    (Object)adaptor.create(EXTENDS, "EXTENDS")
                    , root_2);

                    adaptor.addChild(root_2, stream_type.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_type.reset();

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:399:17: ( ^( IMPLEMENTS typeList ) )?
                if ( stream_typeList.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:399:17: ^( IMPLEMENTS typeList )
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot(
                    (Object)adaptor.create(IMPLEMENTS, "IMPLEMENTS")
                    , root_2);

                    adaptor.addChild(root_2, stream_typeList.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_typeList.reset();

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:400:17: ( classBody )*
                while ( stream_classBody.hasNext() ) {
                    adaptor.addChild(root_1, stream_classBody.nextTree());

                }
                stream_classBody.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 10, normalClassDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "normalClassDeclaration"


    public static class typeParameters_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "typeParameters"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:405:1: typeParameters : '<' typeParameter ( ',' typeParameter )* '>' -> typeParameter ( typeParameter )* ;
    public final JavaTreeParser.typeParameters_return typeParameters() throws RecognitionException {
        JavaTreeParser.typeParameters_return retval = new JavaTreeParser.typeParameters_return();
        retval.start = input.LT(1);

        int typeParameters_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal54=null;
        Token char_literal56=null;
        Token char_literal58=null;
        JavaTreeParser.typeParameter_return typeParameter55 =null;

        JavaTreeParser.typeParameter_return typeParameter57 =null;


        Object char_literal54_tree=null;
        Object char_literal56_tree=null;
        Object char_literal58_tree=null;
        RewriteRuleTokenStream stream_GT=new RewriteRuleTokenStream(adaptor,"token GT");
        RewriteRuleTokenStream stream_LT=new RewriteRuleTokenStream(adaptor,"token LT");
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_typeParameter=new RewriteRuleSubtreeStream(adaptor,"rule typeParameter");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:406:5: ( '<' typeParameter ( ',' typeParameter )* '>' -> typeParameter ( typeParameter )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:406:9: '<' typeParameter ( ',' typeParameter )* '>'
            {
            char_literal54=(Token)match(input,LT,FOLLOW_LT_in_typeParameters1023); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_LT.add(char_literal54);


            pushFollow(FOLLOW_typeParameter_in_typeParameters1037);
            typeParameter55=typeParameter();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_typeParameter.add(typeParameter55.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:408:13: ( ',' typeParameter )*
            loop19:
            do {
                int alt19=2;
                int LA19_0 = input.LA(1);

                if ( (LA19_0==COMMA) ) {
                    alt19=1;
                }


                switch (alt19) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:408:14: ',' typeParameter
            	    {
            	    char_literal56=(Token)match(input,COMMA,FOLLOW_COMMA_in_typeParameters1052); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_COMMA.add(char_literal56);


            	    pushFollow(FOLLOW_typeParameter_in_typeParameters1054);
            	    typeParameter57=typeParameter();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_typeParameter.add(typeParameter57.getTree());

            	    }
            	    break;

            	default :
            	    break loop19;
                }
            } while (true);


            char_literal58=(Token)match(input,GT,FOLLOW_GT_in_typeParameters1079); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_GT.add(char_literal58);


            // AST REWRITE
            // elements: typeParameter, typeParameter
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 411:9: -> typeParameter ( typeParameter )*
            {
                adaptor.addChild(root_0, stream_typeParameter.nextTree());

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:411:26: ( typeParameter )*
                while ( stream_typeParameter.hasNext() ) {
                    adaptor.addChild(root_0, stream_typeParameter.nextTree());

                }
                stream_typeParameter.reset();

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 11, typeParameters_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "typeParameters"


    public static class typeParameter_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "typeParameter"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:414:1: typeParameter : IDENTIFIER ( 'extends' typeBound )? -> IDENTIFIER ( ^( 'extends' typeBound ) )? ;
    public final JavaTreeParser.typeParameter_return typeParameter() throws RecognitionException {
        JavaTreeParser.typeParameter_return retval = new JavaTreeParser.typeParameter_return();
        retval.start = input.LT(1);

        int typeParameter_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER59=null;
        Token string_literal60=null;
        JavaTreeParser.typeBound_return typeBound61 =null;


        Object IDENTIFIER59_tree=null;
        Object string_literal60_tree=null;
        RewriteRuleTokenStream stream_EXTENDS=new RewriteRuleTokenStream(adaptor,"token EXTENDS");
        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
        RewriteRuleSubtreeStream stream_typeBound=new RewriteRuleSubtreeStream(adaptor,"rule typeBound");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:415:5: ( IDENTIFIER ( 'extends' typeBound )? -> IDENTIFIER ( ^( 'extends' typeBound ) )? )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:415:9: IDENTIFIER ( 'extends' typeBound )?
            {
            IDENTIFIER59=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeParameter1114); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER59);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:416:9: ( 'extends' typeBound )?
            int alt20=2;
            int LA20_0 = input.LA(1);

            if ( (LA20_0==EXTENDS) ) {
                alt20=1;
            }
            switch (alt20) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:416:10: 'extends' typeBound
                    {
                    string_literal60=(Token)match(input,EXTENDS,FOLLOW_EXTENDS_in_typeParameter1125); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_EXTENDS.add(string_literal60);


                    pushFollow(FOLLOW_typeBound_in_typeParameter1127);
                    typeBound61=typeBound();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_typeBound.add(typeBound61.getTree());

                    }
                    break;

            }


            // AST REWRITE
            // elements: IDENTIFIER, EXTENDS, typeBound
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 418:9: -> IDENTIFIER ( ^( 'extends' typeBound ) )?
            {
                adaptor.addChild(root_0, 
                stream_IDENTIFIER.nextNode()
                );

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:419:20: ( ^( 'extends' typeBound ) )?
                if ( stream_EXTENDS.hasNext()||stream_typeBound.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:419:20: ^( 'extends' typeBound )
                    {
                    Object root_1 = (Object)adaptor.nil();
                    root_1 = (Object)adaptor.becomeRoot(
                    stream_EXTENDS.nextNode()
                    , root_1);

                    adaptor.addChild(root_1, stream_typeBound.nextTree());

                    adaptor.addChild(root_0, root_1);
                    }

                }
                stream_EXTENDS.reset();
                stream_typeBound.reset();

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 12, typeParameter_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "typeParameter"


    public static class typeBound_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "typeBound"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:423:1: typeBound : type ( '&' type )* ;
    public final JavaTreeParser.typeBound_return typeBound() throws RecognitionException {
        JavaTreeParser.typeBound_return retval = new JavaTreeParser.typeBound_return();
        retval.start = input.LT(1);

        int typeBound_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal63=null;
        JavaTreeParser.type_return type62 =null;

        JavaTreeParser.type_return type64 =null;


        Object char_literal63_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:424:5: ( type ( '&' type )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:424:9: type ( '&' type )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_type_in_typeBound1186);
            type62=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, type62.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:425:9: ( '&' type )*
            loop21:
            do {
                int alt21=2;
                int LA21_0 = input.LA(1);

                if ( (LA21_0==AMP) ) {
                    alt21=1;
                }


                switch (alt21) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:425:10: '&' type
            	    {
            	    char_literal63=(Token)match(input,AMP,FOLLOW_AMP_in_typeBound1197); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal63_tree = 
            	    (Object)adaptor.create(char_literal63)
            	    ;
            	    adaptor.addChild(root_0, char_literal63_tree);
            	    }

            	    pushFollow(FOLLOW_type_in_typeBound1199);
            	    type64=type();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, type64.getTree());

            	    }
            	    break;

            	default :
            	    break loop21;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 13, typeBound_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "typeBound"


    public static class enumDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "enumDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:430:1: enumDeclaration : modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody -> ^( ENUM IDENTIFIER ( ^( IMPLEMENTS typeList ) )? ( enumBody )? ) ;
    public final JavaTreeParser.enumDeclaration_return enumDeclaration() throws RecognitionException {
        JavaTreeParser.enumDeclaration_return retval = new JavaTreeParser.enumDeclaration_return();
        retval.start = input.LT(1);

        int enumDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal66=null;
        Token IDENTIFIER67=null;
        Token string_literal68=null;
        JavaTreeParser.modifiers_return modifiers65 =null;

        JavaTreeParser.typeList_return typeList69 =null;

        JavaTreeParser.enumBody_return enumBody70 =null;


        Object string_literal66_tree=null;
        Object IDENTIFIER67_tree=null;
        Object string_literal68_tree=null;
        RewriteRuleTokenStream stream_ENUM=new RewriteRuleTokenStream(adaptor,"token ENUM");
        RewriteRuleTokenStream stream_IMPLEMENTS=new RewriteRuleTokenStream(adaptor,"token IMPLEMENTS");
        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
        RewriteRuleSubtreeStream stream_enumBody=new RewriteRuleSubtreeStream(adaptor,"rule enumBody");
        RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
        RewriteRuleSubtreeStream stream_typeList=new RewriteRuleSubtreeStream(adaptor,"rule typeList");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:431:5: ( modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody -> ^( ENUM IDENTIFIER ( ^( IMPLEMENTS typeList ) )? ( enumBody )? ) )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:431:9: modifiers ( 'enum' ) IDENTIFIER ( 'implements' typeList )? enumBody
            {
            pushFollow(FOLLOW_modifiers_in_enumDeclaration1231);
            modifiers65=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_modifiers.add(modifiers65.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:432:9: ( 'enum' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:432:10: 'enum'
            {
            string_literal66=(Token)match(input,ENUM,FOLLOW_ENUM_in_enumDeclaration1243); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_ENUM.add(string_literal66);


            }


            IDENTIFIER67=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumDeclaration1264); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER67);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:435:9: ( 'implements' typeList )?
            int alt22=2;
            int LA22_0 = input.LA(1);

            if ( (LA22_0==IMPLEMENTS) ) {
                alt22=1;
            }
            switch (alt22) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:435:10: 'implements' typeList
                    {
                    string_literal68=(Token)match(input,IMPLEMENTS,FOLLOW_IMPLEMENTS_in_enumDeclaration1275); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_IMPLEMENTS.add(string_literal68);


                    pushFollow(FOLLOW_typeList_in_enumDeclaration1277);
                    typeList69=typeList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_typeList.add(typeList69.getTree());

                    }
                    break;

            }


            pushFollow(FOLLOW_enumBody_in_enumDeclaration1298);
            enumBody70=enumBody();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_enumBody.add(enumBody70.getTree());

            // AST REWRITE
            // elements: enumBody, typeList, IDENTIFIER
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 438:9: -> ^( ENUM IDENTIFIER ( ^( IMPLEMENTS typeList ) )? ( enumBody )? )
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:439:9: ^( ENUM IDENTIFIER ( ^( IMPLEMENTS typeList ) )? ( enumBody )? )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(ENUM, "ENUM")
                , root_1);

                adaptor.addChild(root_1, 
                stream_IDENTIFIER.nextNode()
                );

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:440:10: ( ^( IMPLEMENTS typeList ) )?
                if ( stream_typeList.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:440:10: ^( IMPLEMENTS typeList )
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot(
                    (Object)adaptor.create(IMPLEMENTS, "IMPLEMENTS")
                    , root_2);

                    adaptor.addChild(root_2, stream_typeList.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_typeList.reset();

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:441:10: ( enumBody )?
                if ( stream_enumBody.hasNext() ) {
                    adaptor.addChild(root_1, stream_enumBody.nextTree());

                }
                stream_enumBody.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 14, enumDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "enumDeclaration"


    public static class enumBody_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "enumBody"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:445:1: enumBody : '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}' -> ( ^( ENUM_CONST enumConstants ) )? ( ^( ENUM_DECL enumBodyDeclarations ) )? ;
    public final JavaTreeParser.enumBody_return enumBody() throws RecognitionException {
        JavaTreeParser.enumBody_return retval = new JavaTreeParser.enumBody_return();
        retval.start = input.LT(1);

        int enumBody_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal71=null;
        Token char_literal73=null;
        Token char_literal75=null;
        JavaTreeParser.enumConstants_return enumConstants72 =null;

        JavaTreeParser.enumBodyDeclarations_return enumBodyDeclarations74 =null;


        Object char_literal71_tree=null;
        Object char_literal73_tree=null;
        Object char_literal75_tree=null;
        RewriteRuleTokenStream stream_RBRACE=new RewriteRuleTokenStream(adaptor,"token RBRACE");
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleTokenStream stream_LBRACE=new RewriteRuleTokenStream(adaptor,"token LBRACE");
        RewriteRuleSubtreeStream stream_enumBodyDeclarations=new RewriteRuleSubtreeStream(adaptor,"rule enumBodyDeclarations");
        RewriteRuleSubtreeStream stream_enumConstants=new RewriteRuleSubtreeStream(adaptor,"rule enumConstants");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:446:5: ( '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}' -> ( ^( ENUM_CONST enumConstants ) )? ( ^( ENUM_DECL enumBodyDeclarations ) )? )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:446:9: '{' ( enumConstants )? ( ',' )? ( enumBodyDeclarations )? '}'
            {
            char_literal71=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_enumBody1375); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_LBRACE.add(char_literal71);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:447:9: ( enumConstants )?
            int alt23=2;
            int LA23_0 = input.LA(1);

            if ( (LA23_0==IDENTIFIER||LA23_0==MONKEYS_AT) ) {
                alt23=1;
            }
            switch (alt23) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:447:10: enumConstants
                    {
                    pushFollow(FOLLOW_enumConstants_in_enumBody1386);
                    enumConstants72=enumConstants();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_enumConstants.add(enumConstants72.getTree());

                    }
                    break;

            }


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:449:9: ( ',' )?
            int alt24=2;
            int LA24_0 = input.LA(1);

            if ( (LA24_0==COMMA) ) {
                alt24=1;
            }
            switch (alt24) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:449:9: ','
                    {
                    char_literal73=(Token)match(input,COMMA,FOLLOW_COMMA_in_enumBody1408); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_COMMA.add(char_literal73);


                    }
                    break;

            }


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:450:9: ( enumBodyDeclarations )?
            int alt25=2;
            int LA25_0 = input.LA(1);

            if ( (LA25_0==SEMI) ) {
                alt25=1;
            }
            switch (alt25) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:450:10: enumBodyDeclarations
                    {
                    pushFollow(FOLLOW_enumBodyDeclarations_in_enumBody1421);
                    enumBodyDeclarations74=enumBodyDeclarations();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_enumBodyDeclarations.add(enumBodyDeclarations74.getTree());

                    }
                    break;

            }


            char_literal75=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_enumBody1443); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_RBRACE.add(char_literal75);


            // AST REWRITE
            // elements: enumConstants, enumBodyDeclarations
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 453:9: -> ( ^( ENUM_CONST enumConstants ) )? ( ^( ENUM_DECL enumBodyDeclarations ) )?
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:454:9: ( ^( ENUM_CONST enumConstants ) )?
                if ( stream_enumConstants.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:454:9: ^( ENUM_CONST enumConstants )
                    {
                    Object root_1 = (Object)adaptor.nil();
                    root_1 = (Object)adaptor.becomeRoot(
                    (Object)adaptor.create(ENUM_CONST, "ENUM_CONST")
                    , root_1);

                    adaptor.addChild(root_1, stream_enumConstants.nextTree());

                    adaptor.addChild(root_0, root_1);
                    }

                }
                stream_enumConstants.reset();

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:455:9: ( ^( ENUM_DECL enumBodyDeclarations ) )?
                if ( stream_enumBodyDeclarations.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:455:9: ^( ENUM_DECL enumBodyDeclarations )
                    {
                    Object root_1 = (Object)adaptor.nil();
                    root_1 = (Object)adaptor.becomeRoot(
                    (Object)adaptor.create(ENUM_DECL, "ENUM_DECL")
                    , root_1);

                    adaptor.addChild(root_1, stream_enumBodyDeclarations.nextTree());

                    adaptor.addChild(root_0, root_1);
                    }

                }
                stream_enumBodyDeclarations.reset();

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 15, enumBody_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "enumBody"


    public static class enumConstants_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "enumConstants"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:458:1: enumConstants : enumConstant ( ',' enumConstant )* -> enumConstant ( enumConstant )* ;
    public final JavaTreeParser.enumConstants_return enumConstants() throws RecognitionException {
        JavaTreeParser.enumConstants_return retval = new JavaTreeParser.enumConstants_return();
        retval.start = input.LT(1);

        int enumConstants_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal77=null;
        JavaTreeParser.enumConstant_return enumConstant76 =null;

        JavaTreeParser.enumConstant_return enumConstant78 =null;


        Object char_literal77_tree=null;
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_enumConstant=new RewriteRuleSubtreeStream(adaptor,"rule enumConstant");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:459:5: ( enumConstant ( ',' enumConstant )* -> enumConstant ( enumConstant )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:459:9: enumConstant ( ',' enumConstant )*
            {
            pushFollow(FOLLOW_enumConstant_in_enumConstants1503);
            enumConstant76=enumConstant();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_enumConstant.add(enumConstant76.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:460:9: ( ',' enumConstant )*
            loop26:
            do {
                int alt26=2;
                int LA26_0 = input.LA(1);

                if ( (LA26_0==COMMA) ) {
                    int LA26_1 = input.LA(2);

                    if ( (LA26_1==IDENTIFIER||LA26_1==MONKEYS_AT) ) {
                        alt26=1;
                    }


                }


                switch (alt26) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:460:10: ',' enumConstant
            	    {
            	    char_literal77=(Token)match(input,COMMA,FOLLOW_COMMA_in_enumConstants1514); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_COMMA.add(char_literal77);


            	    pushFollow(FOLLOW_enumConstant_in_enumConstants1516);
            	    enumConstant78=enumConstant();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_enumConstant.add(enumConstant78.getTree());

            	    }
            	    break;

            	default :
            	    break loop26;
                }
            } while (true);


            // AST REWRITE
            // elements: enumConstant, enumConstant
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 462:9: -> enumConstant ( enumConstant )*
            {
                adaptor.addChild(root_0, stream_enumConstant.nextTree());

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:462:25: ( enumConstant )*
                while ( stream_enumConstant.hasNext() ) {
                    adaptor.addChild(root_0, stream_enumConstant.nextTree());

                }
                stream_enumConstant.reset();

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 16, enumConstants_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "enumConstants"


    public static class enumConstant_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "enumConstant"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:469:1: enumConstant : ( annotations )? IDENTIFIER ( arguments )? ( classBody )? -> IDENTIFIER ;
    public final JavaTreeParser.enumConstant_return enumConstant() throws RecognitionException {
        JavaTreeParser.enumConstant_return retval = new JavaTreeParser.enumConstant_return();
        retval.start = input.LT(1);

        int enumConstant_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER80=null;
        JavaTreeParser.annotations_return annotations79 =null;

        JavaTreeParser.arguments_return arguments81 =null;

        JavaTreeParser.classBody_return classBody82 =null;


        Object IDENTIFIER80_tree=null;
        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
        RewriteRuleSubtreeStream stream_arguments=new RewriteRuleSubtreeStream(adaptor,"rule arguments");
        RewriteRuleSubtreeStream stream_annotations=new RewriteRuleSubtreeStream(adaptor,"rule annotations");
        RewriteRuleSubtreeStream stream_classBody=new RewriteRuleSubtreeStream(adaptor,"rule classBody");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:470:5: ( ( annotations )? IDENTIFIER ( arguments )? ( classBody )? -> IDENTIFIER )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:470:9: ( annotations )? IDENTIFIER ( arguments )? ( classBody )?
            {
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:470:9: ( annotations )?
            int alt27=2;
            int LA27_0 = input.LA(1);

            if ( (LA27_0==MONKEYS_AT) ) {
                alt27=1;
            }
            switch (alt27) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:470:10: annotations
                    {
                    pushFollow(FOLLOW_annotations_in_enumConstant1565);
                    annotations79=annotations();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_annotations.add(annotations79.getTree());

                    }
                    break;

            }


            IDENTIFIER80=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumConstant1586); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER80);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:473:9: ( arguments )?
            int alt28=2;
            int LA28_0 = input.LA(1);

            if ( (LA28_0==LPAREN) ) {
                alt28=1;
            }
            switch (alt28) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:473:10: arguments
                    {
                    pushFollow(FOLLOW_arguments_in_enumConstant1597);
                    arguments81=arguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_arguments.add(arguments81.getTree());

                    }
                    break;

            }


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:475:9: ( classBody )?
            int alt29=2;
            int LA29_0 = input.LA(1);

            if ( (LA29_0==LBRACE) ) {
                alt29=1;
            }
            switch (alt29) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:475:10: classBody
                    {
                    pushFollow(FOLLOW_classBody_in_enumConstant1619);
                    classBody82=classBody();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_classBody.add(classBody82.getTree());

                    }
                    break;

            }


            // AST REWRITE
            // elements: IDENTIFIER
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 477:9: -> IDENTIFIER
            {
                adaptor.addChild(root_0, 
                stream_IDENTIFIER.nextNode()
                );

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 17, enumConstant_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "enumConstant"


    public static class enumBodyDeclarations_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "enumBodyDeclarations"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:483:1: enumBodyDeclarations : ';' ( classBodyDeclaration )* -> ( classBodyDeclaration )* ;
    public final JavaTreeParser.enumBodyDeclarations_return enumBodyDeclarations() throws RecognitionException {
        JavaTreeParser.enumBodyDeclarations_return retval = new JavaTreeParser.enumBodyDeclarations_return();
        retval.start = input.LT(1);

        int enumBodyDeclarations_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal83=null;
        JavaTreeParser.classBodyDeclaration_return classBodyDeclaration84 =null;


        Object char_literal83_tree=null;
        RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
        RewriteRuleSubtreeStream stream_classBodyDeclaration=new RewriteRuleSubtreeStream(adaptor,"rule classBodyDeclaration");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:484:5: ( ';' ( classBodyDeclaration )* -> ( classBodyDeclaration )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:484:9: ';' ( classBodyDeclaration )*
            {
            char_literal83=(Token)match(input,SEMI,FOLLOW_SEMI_in_enumBodyDeclarations1680); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_SEMI.add(char_literal83);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:485:9: ( classBodyDeclaration )*
            loop30:
            do {
                int alt30=2;
                int LA30_0 = input.LA(1);

                if ( (LA30_0==ABSTRACT||LA30_0==BOOLEAN||LA30_0==BYTE||LA30_0==CHAR||LA30_0==CLASS||LA30_0==DOUBLE||LA30_0==ENUM||LA30_0==FINAL||LA30_0==FLOAT||LA30_0==IDENTIFIER||(LA30_0 >= INT && LA30_0 <= INTERFACE)||LA30_0==LBRACE||LA30_0==LONG||LA30_0==LT||LA30_0==MONKEYS_AT||LA30_0==NATIVE||(LA30_0 >= PRIVATE && LA30_0 <= PUBLIC)||(LA30_0 >= SEMI && LA30_0 <= SHORT)||(LA30_0 >= STATIC && LA30_0 <= STRICTFP)||LA30_0==SYNCHRONIZED||LA30_0==TRANSIENT||(LA30_0 >= VOID && LA30_0 <= VOLATILE)) ) {
                    alt30=1;
                }


                switch (alt30) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:485:10: classBodyDeclaration
            	    {
            	    pushFollow(FOLLOW_classBodyDeclaration_in_enumBodyDeclarations1692);
            	    classBodyDeclaration84=classBodyDeclaration();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_classBodyDeclaration.add(classBodyDeclaration84.getTree());

            	    }
            	    break;

            	default :
            	    break loop30;
                }
            } while (true);


            // AST REWRITE
            // elements: classBodyDeclaration
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 487:9: -> ( classBodyDeclaration )*
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:488:9: ( classBodyDeclaration )*
                while ( stream_classBodyDeclaration.hasNext() ) {
                    adaptor.addChild(root_0, stream_classBodyDeclaration.nextTree());

                }
                stream_classBodyDeclaration.reset();

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 18, enumBodyDeclarations_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "enumBodyDeclarations"


    public static class interfaceDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "interfaceDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:491:1: interfaceDeclaration : ( normalInterfaceDeclaration | annotationTypeDeclaration );
    public final JavaTreeParser.interfaceDeclaration_return interfaceDeclaration() throws RecognitionException {
        JavaTreeParser.interfaceDeclaration_return retval = new JavaTreeParser.interfaceDeclaration_return();
        retval.start = input.LT(1);

        int interfaceDeclaration_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.normalInterfaceDeclaration_return normalInterfaceDeclaration85 =null;

        JavaTreeParser.annotationTypeDeclaration_return annotationTypeDeclaration86 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 19) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:492:5: ( normalInterfaceDeclaration | annotationTypeDeclaration )
            int alt31=2;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA31_1 = input.LA(2);

                if ( (synpred43_JavaTree()) ) {
                    alt31=1;
                }
                else if ( (true) ) {
                    alt31=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA31_2 = input.LA(2);

                if ( (synpred43_JavaTree()) ) {
                    alt31=1;
                }
                else if ( (true) ) {
                    alt31=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA31_3 = input.LA(2);

                if ( (synpred43_JavaTree()) ) {
                    alt31=1;
                }
                else if ( (true) ) {
                    alt31=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA31_4 = input.LA(2);

                if ( (synpred43_JavaTree()) ) {
                    alt31=1;
                }
                else if ( (true) ) {
                    alt31=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA31_5 = input.LA(2);

                if ( (synpred43_JavaTree()) ) {
                    alt31=1;
                }
                else if ( (true) ) {
                    alt31=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA31_6 = input.LA(2);

                if ( (synpred43_JavaTree()) ) {
                    alt31=1;
                }
                else if ( (true) ) {
                    alt31=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA31_7 = input.LA(2);

                if ( (synpred43_JavaTree()) ) {
                    alt31=1;
                }
                else if ( (true) ) {
                    alt31=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA31_8 = input.LA(2);

                if ( (synpred43_JavaTree()) ) {
                    alt31=1;
                }
                else if ( (true) ) {
                    alt31=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA31_9 = input.LA(2);

                if ( (synpred43_JavaTree()) ) {
                    alt31=1;
                }
                else if ( (true) ) {
                    alt31=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA31_10 = input.LA(2);

                if ( (synpred43_JavaTree()) ) {
                    alt31=1;
                }
                else if ( (true) ) {
                    alt31=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA31_11 = input.LA(2);

                if ( (synpred43_JavaTree()) ) {
                    alt31=1;
                }
                else if ( (true) ) {
                    alt31=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA31_12 = input.LA(2);

                if ( (synpred43_JavaTree()) ) {
                    alt31=1;
                }
                else if ( (true) ) {
                    alt31=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 31, 12, input);

                    throw nvae;

                }
                }
                break;
            case INTERFACE:
                {
                alt31=1;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 31, 0, input);

                throw nvae;

            }

            switch (alt31) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:492:9: normalInterfaceDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration1744);
                    normalInterfaceDeclaration85=normalInterfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, normalInterfaceDeclaration85.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:493:9: annotationTypeDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_annotationTypeDeclaration_in_interfaceDeclaration1754);
                    annotationTypeDeclaration86=annotationTypeDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, annotationTypeDeclaration86.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 19, interfaceDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "interfaceDeclaration"


    public static class normalInterfaceDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "normalInterfaceDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:496:1: normalInterfaceDeclaration : modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody -> ^( INTERFACE IDENTIFIER ( modifiers )* ( ^( GENERICS typeParameters ) )? ( ^( EXTENDS typeList ) )? ( interfaceBody )* ) ;
    public final JavaTreeParser.normalInterfaceDeclaration_return normalInterfaceDeclaration() throws RecognitionException {
        JavaTreeParser.normalInterfaceDeclaration_return retval = new JavaTreeParser.normalInterfaceDeclaration_return();
        retval.start = input.LT(1);

        int normalInterfaceDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal88=null;
        Token IDENTIFIER89=null;
        Token string_literal91=null;
        JavaTreeParser.modifiers_return modifiers87 =null;

        JavaTreeParser.typeParameters_return typeParameters90 =null;

        JavaTreeParser.typeList_return typeList92 =null;

        JavaTreeParser.interfaceBody_return interfaceBody93 =null;


        Object string_literal88_tree=null;
        Object IDENTIFIER89_tree=null;
        Object string_literal91_tree=null;
        RewriteRuleTokenStream stream_INTERFACE=new RewriteRuleTokenStream(adaptor,"token INTERFACE");
        RewriteRuleTokenStream stream_EXTENDS=new RewriteRuleTokenStream(adaptor,"token EXTENDS");
        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
        RewriteRuleSubtreeStream stream_typeParameters=new RewriteRuleSubtreeStream(adaptor,"rule typeParameters");
        RewriteRuleSubtreeStream stream_interfaceBody=new RewriteRuleSubtreeStream(adaptor,"rule interfaceBody");
        RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
        RewriteRuleSubtreeStream stream_typeList=new RewriteRuleSubtreeStream(adaptor,"rule typeList");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 20) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:497:5: ( modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody -> ^( INTERFACE IDENTIFIER ( modifiers )* ( ^( GENERICS typeParameters ) )? ( ^( EXTENDS typeList ) )? ( interfaceBody )* ) )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:497:9: modifiers 'interface' IDENTIFIER ( typeParameters )? ( 'extends' typeList )? interfaceBody
            {
            pushFollow(FOLLOW_modifiers_in_normalInterfaceDeclaration1778);
            modifiers87=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_modifiers.add(modifiers87.getTree());

            string_literal88=(Token)match(input,INTERFACE,FOLLOW_INTERFACE_in_normalInterfaceDeclaration1780); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_INTERFACE.add(string_literal88);


            IDENTIFIER89=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalInterfaceDeclaration1782); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER89);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:498:9: ( typeParameters )?
            int alt32=2;
            int LA32_0 = input.LA(1);

            if ( (LA32_0==LT) ) {
                alt32=1;
            }
            switch (alt32) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:498:10: typeParameters
                    {
                    pushFollow(FOLLOW_typeParameters_in_normalInterfaceDeclaration1793);
                    typeParameters90=typeParameters();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_typeParameters.add(typeParameters90.getTree());

                    }
                    break;

            }


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:500:9: ( 'extends' typeList )?
            int alt33=2;
            int LA33_0 = input.LA(1);

            if ( (LA33_0==EXTENDS) ) {
                alt33=1;
            }
            switch (alt33) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:500:10: 'extends' typeList
                    {
                    string_literal91=(Token)match(input,EXTENDS,FOLLOW_EXTENDS_in_normalInterfaceDeclaration1815); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_EXTENDS.add(string_literal91);


                    pushFollow(FOLLOW_typeList_in_normalInterfaceDeclaration1817);
                    typeList92=typeList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_typeList.add(typeList92.getTree());

                    }
                    break;

            }


            pushFollow(FOLLOW_interfaceBody_in_normalInterfaceDeclaration1838);
            interfaceBody93=interfaceBody();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_interfaceBody.add(interfaceBody93.getTree());

            // AST REWRITE
            // elements: IDENTIFIER, interfaceBody, typeList, modifiers, typeParameters
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 503:9: -> ^( INTERFACE IDENTIFIER ( modifiers )* ( ^( GENERICS typeParameters ) )? ( ^( EXTENDS typeList ) )? ( interfaceBody )* )
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:504:9: ^( INTERFACE IDENTIFIER ( modifiers )* ( ^( GENERICS typeParameters ) )? ( ^( EXTENDS typeList ) )? ( interfaceBody )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(INTERFACE, "INTERFACE")
                , root_1);

                adaptor.addChild(root_1, 
                stream_IDENTIFIER.nextNode()
                );

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:504:32: ( modifiers )*
                while ( stream_modifiers.hasNext() ) {
                    adaptor.addChild(root_1, stream_modifiers.nextTree());

                }
                stream_modifiers.reset();

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:505:14: ( ^( GENERICS typeParameters ) )?
                if ( stream_typeParameters.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:505:14: ^( GENERICS typeParameters )
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot(
                    (Object)adaptor.create(GENERICS, "GENERICS")
                    , root_2);

                    adaptor.addChild(root_2, stream_typeParameters.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_typeParameters.reset();

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:506:21: ( ^( EXTENDS typeList ) )?
                if ( stream_typeList.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:506:21: ^( EXTENDS typeList )
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot(
                    (Object)adaptor.create(EXTENDS, "EXTENDS")
                    , root_2);

                    adaptor.addChild(root_2, stream_typeList.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_typeList.reset();

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:507:7: ( interfaceBody )*
                while ( stream_interfaceBody.hasNext() ) {
                    adaptor.addChild(root_1, stream_interfaceBody.nextTree());

                }
                stream_interfaceBody.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 20, normalInterfaceDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "normalInterfaceDeclaration"


    public static class typeList_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "typeList"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:510:1: typeList : type ( ',' type )* -> type ( type )* ;
    public final JavaTreeParser.typeList_return typeList() throws RecognitionException {
        JavaTreeParser.typeList_return retval = new JavaTreeParser.typeList_return();
        retval.start = input.LT(1);

        int typeList_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal95=null;
        JavaTreeParser.type_return type94 =null;

        JavaTreeParser.type_return type96 =null;


        Object char_literal95_tree=null;
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:511:5: ( type ( ',' type )* -> type ( type )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:511:9: type ( ',' type )*
            {
            pushFollow(FOLLOW_type_in_typeList1941);
            type94=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_type.add(type94.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:512:9: ( ',' type )*
            loop34:
            do {
                int alt34=2;
                int LA34_0 = input.LA(1);

                if ( (LA34_0==COMMA) ) {
                    alt34=1;
                }


                switch (alt34) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:512:10: ',' type
            	    {
            	    char_literal95=(Token)match(input,COMMA,FOLLOW_COMMA_in_typeList1952); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_COMMA.add(char_literal95);


            	    pushFollow(FOLLOW_type_in_typeList1954);
            	    type96=type();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_type.add(type96.getTree());

            	    }
            	    break;

            	default :
            	    break loop34;
                }
            } while (true);


            // AST REWRITE
            // elements: type, type
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 514:9: -> type ( type )*
            {
                adaptor.addChild(root_0, stream_type.nextTree());

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:515:14: ( type )*
                while ( stream_type.hasNext() ) {
                    adaptor.addChild(root_0, stream_type.nextTree());

                }
                stream_type.reset();

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 21, typeList_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "typeList"


    public static class classBody_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "classBody"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:518:1: classBody : '{' ( classBodyDeclaration )* '}' -> ^( CLASSBODY ( classBodyDeclaration )* ) ;
    public final JavaTreeParser.classBody_return classBody() throws RecognitionException {
        JavaTreeParser.classBody_return retval = new JavaTreeParser.classBody_return();
        retval.start = input.LT(1);

        int classBody_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal97=null;
        Token char_literal99=null;
        JavaTreeParser.classBodyDeclaration_return classBodyDeclaration98 =null;


        Object char_literal97_tree=null;
        Object char_literal99_tree=null;
        RewriteRuleTokenStream stream_RBRACE=new RewriteRuleTokenStream(adaptor,"token RBRACE");
        RewriteRuleTokenStream stream_LBRACE=new RewriteRuleTokenStream(adaptor,"token LBRACE");
        RewriteRuleSubtreeStream stream_classBodyDeclaration=new RewriteRuleSubtreeStream(adaptor,"rule classBodyDeclaration");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 22) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:519:5: ( '{' ( classBodyDeclaration )* '}' -> ^( CLASSBODY ( classBodyDeclaration )* ) )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:519:9: '{' ( classBodyDeclaration )* '}'
            {
            char_literal97=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_classBody2008); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_LBRACE.add(char_literal97);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:520:9: ( classBodyDeclaration )*
            loop35:
            do {
                int alt35=2;
                int LA35_0 = input.LA(1);

                if ( (LA35_0==ABSTRACT||LA35_0==BOOLEAN||LA35_0==BYTE||LA35_0==CHAR||LA35_0==CLASS||LA35_0==DOUBLE||LA35_0==ENUM||LA35_0==FINAL||LA35_0==FLOAT||LA35_0==IDENTIFIER||(LA35_0 >= INT && LA35_0 <= INTERFACE)||LA35_0==LBRACE||LA35_0==LONG||LA35_0==LT||LA35_0==MONKEYS_AT||LA35_0==NATIVE||(LA35_0 >= PRIVATE && LA35_0 <= PUBLIC)||(LA35_0 >= SEMI && LA35_0 <= SHORT)||(LA35_0 >= STATIC && LA35_0 <= STRICTFP)||LA35_0==SYNCHRONIZED||LA35_0==TRANSIENT||(LA35_0 >= VOID && LA35_0 <= VOLATILE)) ) {
                    alt35=1;
                }


                switch (alt35) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:520:10: classBodyDeclaration
            	    {
            	    pushFollow(FOLLOW_classBodyDeclaration_in_classBody2020);
            	    classBodyDeclaration98=classBodyDeclaration();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_classBodyDeclaration.add(classBodyDeclaration98.getTree());

            	    }
            	    break;

            	default :
            	    break loop35;
                }
            } while (true);


            char_literal99=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_classBody2042); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_RBRACE.add(char_literal99);


            // AST REWRITE
            // elements: classBodyDeclaration
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 523:9: -> ^( CLASSBODY ( classBodyDeclaration )* )
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:524:9: ^( CLASSBODY ( classBodyDeclaration )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(CLASSBODY, "CLASSBODY")
                , root_1);

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:524:21: ( classBodyDeclaration )*
                while ( stream_classBodyDeclaration.hasNext() ) {
                    adaptor.addChild(root_1, stream_classBodyDeclaration.nextTree());

                }
                stream_classBodyDeclaration.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 22, classBody_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "classBody"


    public static class interfaceBody_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "interfaceBody"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:527:1: interfaceBody : '{' ( interfaceBodyDeclaration )* '}' -> ( interfaceBodyDeclaration )* ;
    public final JavaTreeParser.interfaceBody_return interfaceBody() throws RecognitionException {
        JavaTreeParser.interfaceBody_return retval = new JavaTreeParser.interfaceBody_return();
        retval.start = input.LT(1);

        int interfaceBody_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal100=null;
        Token char_literal102=null;
        JavaTreeParser.interfaceBodyDeclaration_return interfaceBodyDeclaration101 =null;


        Object char_literal100_tree=null;
        Object char_literal102_tree=null;
        RewriteRuleTokenStream stream_RBRACE=new RewriteRuleTokenStream(adaptor,"token RBRACE");
        RewriteRuleTokenStream stream_LBRACE=new RewriteRuleTokenStream(adaptor,"token LBRACE");
        RewriteRuleSubtreeStream stream_interfaceBodyDeclaration=new RewriteRuleSubtreeStream(adaptor,"rule interfaceBodyDeclaration");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 23) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:528:5: ( '{' ( interfaceBodyDeclaration )* '}' -> ( interfaceBodyDeclaration )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:528:9: '{' ( interfaceBodyDeclaration )* '}'
            {
            char_literal100=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_interfaceBody2087); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_LBRACE.add(char_literal100);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:529:9: ( interfaceBodyDeclaration )*
            loop36:
            do {
                int alt36=2;
                int LA36_0 = input.LA(1);

                if ( (LA36_0==ABSTRACT||LA36_0==BOOLEAN||LA36_0==BYTE||LA36_0==CHAR||LA36_0==CLASS||LA36_0==DOUBLE||LA36_0==ENUM||LA36_0==FINAL||LA36_0==FLOAT||LA36_0==IDENTIFIER||(LA36_0 >= INT && LA36_0 <= INTERFACE)||LA36_0==LONG||LA36_0==LT||LA36_0==MONKEYS_AT||LA36_0==NATIVE||(LA36_0 >= PRIVATE && LA36_0 <= PUBLIC)||(LA36_0 >= SEMI && LA36_0 <= SHORT)||(LA36_0 >= STATIC && LA36_0 <= STRICTFP)||LA36_0==SYNCHRONIZED||LA36_0==TRANSIENT||(LA36_0 >= VOID && LA36_0 <= VOLATILE)) ) {
                    alt36=1;
                }


                switch (alt36) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:529:10: interfaceBodyDeclaration
            	    {
            	    pushFollow(FOLLOW_interfaceBodyDeclaration_in_interfaceBody2099);
            	    interfaceBodyDeclaration101=interfaceBodyDeclaration();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_interfaceBodyDeclaration.add(interfaceBodyDeclaration101.getTree());

            	    }
            	    break;

            	default :
            	    break loop36;
                }
            } while (true);


            char_literal102=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_interfaceBody2121); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_RBRACE.add(char_literal102);


            // AST REWRITE
            // elements: interfaceBodyDeclaration
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 532:9: -> ( interfaceBodyDeclaration )*
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:532:12: ( interfaceBodyDeclaration )*
                while ( stream_interfaceBodyDeclaration.hasNext() ) {
                    adaptor.addChild(root_0, stream_interfaceBodyDeclaration.nextTree());

                }
                stream_interfaceBodyDeclaration.reset();

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 23, interfaceBody_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "interfaceBody"


    public static class classBodyDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "classBodyDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:535:1: classBodyDeclaration : ( ';' ->| ( 'static' )? block ->| memberDecl );
    public final JavaTreeParser.classBodyDeclaration_return classBodyDeclaration() throws RecognitionException {
        JavaTreeParser.classBodyDeclaration_return retval = new JavaTreeParser.classBodyDeclaration_return();
        retval.start = input.LT(1);

        int classBodyDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal103=null;
        Token string_literal104=null;
        JavaTreeParser.block_return block105 =null;

        JavaTreeParser.memberDecl_return memberDecl106 =null;


        Object char_literal103_tree=null;
        Object string_literal104_tree=null;
        RewriteRuleTokenStream stream_STATIC=new RewriteRuleTokenStream(adaptor,"token STATIC");
        RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
        RewriteRuleSubtreeStream stream_block=new RewriteRuleSubtreeStream(adaptor,"rule block");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 24) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:536:5: ( ';' ->| ( 'static' )? block ->| memberDecl )
            int alt38=3;
            switch ( input.LA(1) ) {
            case SEMI:
                {
                alt38=1;
                }
                break;
            case STATIC:
                {
                int LA38_2 = input.LA(2);

                if ( (LA38_2==LBRACE) ) {
                    alt38=2;
                }
                else if ( (LA38_2==ABSTRACT||LA38_2==BOOLEAN||LA38_2==BYTE||LA38_2==CHAR||LA38_2==CLASS||LA38_2==DOUBLE||LA38_2==ENUM||LA38_2==FINAL||LA38_2==FLOAT||LA38_2==IDENTIFIER||(LA38_2 >= INT && LA38_2 <= INTERFACE)||LA38_2==LONG||LA38_2==LT||LA38_2==MONKEYS_AT||LA38_2==NATIVE||(LA38_2 >= PRIVATE && LA38_2 <= PUBLIC)||LA38_2==SHORT||(LA38_2 >= STATIC && LA38_2 <= STRICTFP)||LA38_2==SYNCHRONIZED||LA38_2==TRANSIENT||(LA38_2 >= VOID && LA38_2 <= VOLATILE)) ) {
                    alt38=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 38, 2, input);

                    throw nvae;

                }
                }
                break;
            case LBRACE:
                {
                alt38=2;
                }
                break;
            case ABSTRACT:
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CLASS:
            case DOUBLE:
            case ENUM:
            case FINAL:
            case FLOAT:
            case IDENTIFIER:
            case INT:
            case INTERFACE:
            case LONG:
            case LT:
            case MONKEYS_AT:
            case NATIVE:
            case PRIVATE:
            case PROTECTED:
            case PUBLIC:
            case SHORT:
            case STRICTFP:
            case SYNCHRONIZED:
            case TRANSIENT:
            case VOID:
            case VOLATILE:
                {
                alt38=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 38, 0, input);

                throw nvae;

            }

            switch (alt38) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:536:9: ';'
                    {
                    char_literal103=(Token)match(input,SEMI,FOLLOW_SEMI_in_classBodyDeclaration2154); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_SEMI.add(char_literal103);


                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 536:13: ->
                    {
                        root_0 = null;
                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:537:9: ( 'static' )? block
                    {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:537:9: ( 'static' )?
                    int alt37=2;
                    int LA37_0 = input.LA(1);

                    if ( (LA37_0==STATIC) ) {
                        alt37=1;
                    }
                    switch (alt37) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:537:10: 'static'
                            {
                            string_literal104=(Token)match(input,STATIC,FOLLOW_STATIC_in_classBodyDeclaration2168); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_STATIC.add(string_literal104);


                            }
                            break;

                    }


                    pushFollow(FOLLOW_block_in_classBodyDeclaration2190);
                    block105=block();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_block.add(block105.getTree());

                    // AST REWRITE
                    // elements: 
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 539:15: ->
                    {
                        root_0 = null;
                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:540:9: memberDecl
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_memberDecl_in_classBodyDeclaration2203);
                    memberDecl106=memberDecl();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, memberDecl106.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 24, classBodyDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "classBodyDeclaration"


    public static class memberDecl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "memberDecl"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:543:1: memberDecl : ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration );
    public final JavaTreeParser.memberDecl_return memberDecl() throws RecognitionException {
        JavaTreeParser.memberDecl_return retval = new JavaTreeParser.memberDecl_return();
        retval.start = input.LT(1);

        int memberDecl_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.fieldDeclaration_return fieldDeclaration107 =null;

        JavaTreeParser.methodDeclaration_return methodDeclaration108 =null;

        JavaTreeParser.classDeclaration_return classDeclaration109 =null;

        JavaTreeParser.interfaceDeclaration_return interfaceDeclaration110 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 25) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:544:5: ( fieldDeclaration | methodDeclaration | classDeclaration | interfaceDeclaration )
            int alt39=4;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA39_1 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else if ( (synpred54_JavaTree()) ) {
                    alt39=3;
                }
                else if ( (true) ) {
                    alt39=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA39_2 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else if ( (synpred54_JavaTree()) ) {
                    alt39=3;
                }
                else if ( (true) ) {
                    alt39=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA39_3 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else if ( (synpred54_JavaTree()) ) {
                    alt39=3;
                }
                else if ( (true) ) {
                    alt39=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA39_4 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else if ( (synpred54_JavaTree()) ) {
                    alt39=3;
                }
                else if ( (true) ) {
                    alt39=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA39_5 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else if ( (synpred54_JavaTree()) ) {
                    alt39=3;
                }
                else if ( (true) ) {
                    alt39=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA39_6 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else if ( (synpred54_JavaTree()) ) {
                    alt39=3;
                }
                else if ( (true) ) {
                    alt39=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA39_7 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else if ( (synpred54_JavaTree()) ) {
                    alt39=3;
                }
                else if ( (true) ) {
                    alt39=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA39_8 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else if ( (synpred54_JavaTree()) ) {
                    alt39=3;
                }
                else if ( (true) ) {
                    alt39=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA39_9 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else if ( (synpred54_JavaTree()) ) {
                    alt39=3;
                }
                else if ( (true) ) {
                    alt39=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA39_10 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else if ( (synpred54_JavaTree()) ) {
                    alt39=3;
                }
                else if ( (true) ) {
                    alt39=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA39_11 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else if ( (synpred54_JavaTree()) ) {
                    alt39=3;
                }
                else if ( (true) ) {
                    alt39=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA39_12 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else if ( (synpred54_JavaTree()) ) {
                    alt39=3;
                }
                else if ( (true) ) {
                    alt39=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 12, input);

                    throw nvae;

                }
                }
                break;
            case IDENTIFIER:
                {
                int LA39_13 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 13, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case INT:
            case LONG:
            case SHORT:
                {
                int LA39_14 = input.LA(2);

                if ( (synpred52_JavaTree()) ) {
                    alt39=1;
                }
                else if ( (synpred53_JavaTree()) ) {
                    alt39=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 39, 14, input);

                    throw nvae;

                }
                }
                break;
            case LT:
            case VOID:
                {
                alt39=2;
                }
                break;
            case CLASS:
            case ENUM:
                {
                alt39=3;
                }
                break;
            case INTERFACE:
                {
                alt39=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 39, 0, input);

                throw nvae;

            }

            switch (alt39) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:544:10: fieldDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_fieldDeclaration_in_memberDecl2224);
                    fieldDeclaration107=fieldDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, fieldDeclaration107.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:545:10: methodDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_methodDeclaration_in_memberDecl2235);
                    methodDeclaration108=methodDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, methodDeclaration108.getTree());

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:546:10: classDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_classDeclaration_in_memberDecl2246);
                    classDeclaration109=classDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, classDeclaration109.getTree());

                    }
                    break;
                case 4 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:547:10: interfaceDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_interfaceDeclaration_in_memberDecl2257);
                    interfaceDeclaration110=interfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, interfaceDeclaration110.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 25, memberDecl_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "memberDecl"


    public static class methodDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "methodDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:551:1: methodDeclaration : ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( NAME IDENTIFIER ) ^( PARA formalParameters ) ( ^( THROWS qualifiedNameList ) )? ) | modifiers ( typeParameters )? type IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN type ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? ) | modifiers ( typeParameters )? 'void' IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN 'void' ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? ) );
    public final JavaTreeParser.methodDeclaration_return methodDeclaration() throws RecognitionException {
        JavaTreeParser.methodDeclaration_return retval = new JavaTreeParser.methodDeclaration_return();
        retval.start = input.LT(1);

        int methodDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER113=null;
        Token string_literal115=null;
        Token char_literal117=null;
        Token char_literal120=null;
        Token IDENTIFIER124=null;
        Token char_literal126=null;
        Token char_literal127=null;
        Token string_literal128=null;
        Token char_literal131=null;
        Token string_literal134=null;
        Token IDENTIFIER135=null;
        Token char_literal137=null;
        Token char_literal138=null;
        Token string_literal139=null;
        Token char_literal142=null;
        JavaTreeParser.modifiers_return modifiers111 =null;

        JavaTreeParser.typeParameters_return typeParameters112 =null;

        JavaTreeParser.formalParameters_return formalParameters114 =null;

        JavaTreeParser.qualifiedNameList_return qualifiedNameList116 =null;

        JavaTreeParser.explicitConstructorInvocation_return explicitConstructorInvocation118 =null;

        JavaTreeParser.blockStatement_return blockStatement119 =null;

        JavaTreeParser.modifiers_return modifiers121 =null;

        JavaTreeParser.typeParameters_return typeParameters122 =null;

        JavaTreeParser.type_return type123 =null;

        JavaTreeParser.formalParameters_return formalParameters125 =null;

        JavaTreeParser.qualifiedNameList_return qualifiedNameList129 =null;

        JavaTreeParser.block_return block130 =null;

        JavaTreeParser.modifiers_return modifiers132 =null;

        JavaTreeParser.typeParameters_return typeParameters133 =null;

        JavaTreeParser.formalParameters_return formalParameters136 =null;

        JavaTreeParser.qualifiedNameList_return qualifiedNameList140 =null;

        JavaTreeParser.block_return block141 =null;


        Object IDENTIFIER113_tree=null;
        Object string_literal115_tree=null;
        Object char_literal117_tree=null;
        Object char_literal120_tree=null;
        Object IDENTIFIER124_tree=null;
        Object char_literal126_tree=null;
        Object char_literal127_tree=null;
        Object string_literal128_tree=null;
        Object char_literal131_tree=null;
        Object string_literal134_tree=null;
        Object IDENTIFIER135_tree=null;
        Object char_literal137_tree=null;
        Object char_literal138_tree=null;
        Object string_literal139_tree=null;
        Object char_literal142_tree=null;
        RewriteRuleTokenStream stream_LBRACKET=new RewriteRuleTokenStream(adaptor,"token LBRACKET");
        RewriteRuleTokenStream stream_THROWS=new RewriteRuleTokenStream(adaptor,"token THROWS");
        RewriteRuleTokenStream stream_VOID=new RewriteRuleTokenStream(adaptor,"token VOID");
        RewriteRuleTokenStream stream_RBRACE=new RewriteRuleTokenStream(adaptor,"token RBRACE");
        RewriteRuleTokenStream stream_RBRACKET=new RewriteRuleTokenStream(adaptor,"token RBRACKET");
        RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
        RewriteRuleTokenStream stream_LBRACE=new RewriteRuleTokenStream(adaptor,"token LBRACE");
        RewriteRuleSubtreeStream stream_explicitConstructorInvocation=new RewriteRuleSubtreeStream(adaptor,"rule explicitConstructorInvocation");
        RewriteRuleSubtreeStream stream_typeParameters=new RewriteRuleSubtreeStream(adaptor,"rule typeParameters");
        RewriteRuleSubtreeStream stream_formalParameters=new RewriteRuleSubtreeStream(adaptor,"rule formalParameters");
        RewriteRuleSubtreeStream stream_block=new RewriteRuleSubtreeStream(adaptor,"rule block");
        RewriteRuleSubtreeStream stream_blockStatement=new RewriteRuleSubtreeStream(adaptor,"rule blockStatement");
        RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
        RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
        RewriteRuleSubtreeStream stream_qualifiedNameList=new RewriteRuleSubtreeStream(adaptor,"rule qualifiedNameList");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 26) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:552:5: ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( NAME IDENTIFIER ) ^( PARA formalParameters ) ( ^( THROWS qualifiedNameList ) )? ) | modifiers ( typeParameters )? type IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN type ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? ) | modifiers ( typeParameters )? 'void' IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN 'void' ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? ) )
            int alt52=3;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA52_1 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA52_2 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA52_3 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA52_4 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA52_5 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA52_6 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA52_7 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA52_8 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA52_9 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA52_10 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA52_11 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA52_12 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 12, input);

                    throw nvae;

                }
                }
                break;
            case LT:
                {
                int LA52_13 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else if ( (true) ) {
                    alt52=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 13, input);

                    throw nvae;

                }
                }
                break;
            case IDENTIFIER:
                {
                int LA52_14 = input.LA(2);

                if ( (synpred59_JavaTree()) ) {
                    alt52=1;
                }
                else if ( (synpred64_JavaTree()) ) {
                    alt52=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 52, 14, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case INT:
            case LONG:
            case SHORT:
                {
                alt52=2;
                }
                break;
            case VOID:
                {
                alt52=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 52, 0, input);

                throw nvae;

            }

            switch (alt52) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:554:10: modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}'
                    {
                    pushFollow(FOLLOW_modifiers_in_methodDeclaration2295);
                    modifiers111=modifiers();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_modifiers.add(modifiers111.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:555:9: ( typeParameters )?
                    int alt40=2;
                    int LA40_0 = input.LA(1);

                    if ( (LA40_0==LT) ) {
                        alt40=1;
                    }
                    switch (alt40) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:555:10: typeParameters
                            {
                            pushFollow(FOLLOW_typeParameters_in_methodDeclaration2306);
                            typeParameters112=typeParameters();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_typeParameters.add(typeParameters112.getTree());

                            }
                            break;

                    }


                    IDENTIFIER113=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration2327); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER113);


                    pushFollow(FOLLOW_formalParameters_in_methodDeclaration2337);
                    formalParameters114=formalParameters();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_formalParameters.add(formalParameters114.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:559:9: ( 'throws' qualifiedNameList )?
                    int alt41=2;
                    int LA41_0 = input.LA(1);

                    if ( (LA41_0==THROWS) ) {
                        alt41=1;
                    }
                    switch (alt41) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:559:10: 'throws' qualifiedNameList
                            {
                            string_literal115=(Token)match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration2348); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_THROWS.add(string_literal115);


                            pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration2350);
                            qualifiedNameList116=qualifiedNameList();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_qualifiedNameList.add(qualifiedNameList116.getTree());

                            }
                            break;

                    }


                    char_literal117=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_methodDeclaration2371); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_LBRACE.add(char_literal117);


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:562:9: ( explicitConstructorInvocation )?
                    int alt42=2;
                    switch ( input.LA(1) ) {
                        case LT:
                            {
                            alt42=1;
                            }
                            break;
                        case THIS:
                            {
                            int LA42_2 = input.LA(2);

                            if ( (synpred57_JavaTree()) ) {
                                alt42=1;
                            }
                            }
                            break;
                        case LPAREN:
                            {
                            int LA42_3 = input.LA(2);

                            if ( (synpred57_JavaTree()) ) {
                                alt42=1;
                            }
                            }
                            break;
                        case SUPER:
                            {
                            int LA42_4 = input.LA(2);

                            if ( (synpred57_JavaTree()) ) {
                                alt42=1;
                            }
                            }
                            break;
                        case IDENTIFIER:
                            {
                            int LA42_5 = input.LA(2);

                            if ( (synpred57_JavaTree()) ) {
                                alt42=1;
                            }
                            }
                            break;
                        case CHARLITERAL:
                        case DOUBLELITERAL:
                        case FALSE:
                        case FLOATLITERAL:
                        case INTLITERAL:
                        case LONGLITERAL:
                        case NULL:
                        case STRINGLITERAL:
                        case TRUE:
                            {
                            int LA42_6 = input.LA(2);

                            if ( (synpred57_JavaTree()) ) {
                                alt42=1;
                            }
                            }
                            break;
                        case NEW:
                            {
                            int LA42_7 = input.LA(2);

                            if ( (synpred57_JavaTree()) ) {
                                alt42=1;
                            }
                            }
                            break;
                        case BOOLEAN:
                        case BYTE:
                        case CHAR:
                        case DOUBLE:
                        case FLOAT:
                        case INT:
                        case LONG:
                        case SHORT:
                            {
                            int LA42_8 = input.LA(2);

                            if ( (synpred57_JavaTree()) ) {
                                alt42=1;
                            }
                            }
                            break;
                        case VOID:
                            {
                            int LA42_9 = input.LA(2);

                            if ( (synpred57_JavaTree()) ) {
                                alt42=1;
                            }
                            }
                            break;
                    }

                    switch (alt42) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:562:10: explicitConstructorInvocation
                            {
                            pushFollow(FOLLOW_explicitConstructorInvocation_in_methodDeclaration2383);
                            explicitConstructorInvocation118=explicitConstructorInvocation();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_explicitConstructorInvocation.add(explicitConstructorInvocation118.getTree());

                            }
                            break;

                    }


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:564:9: ( blockStatement )*
                    loop43:
                    do {
                        int alt43=2;
                        int LA43_0 = input.LA(1);

                        if ( (LA43_0==ABSTRACT||(LA43_0 >= ASSERT && LA43_0 <= BANG)||(LA43_0 >= BOOLEAN && LA43_0 <= BYTE)||(LA43_0 >= CHAR && LA43_0 <= CLASS)||LA43_0==CONTINUE||LA43_0==DO||(LA43_0 >= DOUBLE && LA43_0 <= DOUBLELITERAL)||LA43_0==ENUM||LA43_0==FALSE||LA43_0==FINAL||(LA43_0 >= FLOAT && LA43_0 <= FOR)||(LA43_0 >= IDENTIFIER && LA43_0 <= IF)||(LA43_0 >= INT && LA43_0 <= INTLITERAL)||LA43_0==LBRACE||(LA43_0 >= LONG && LA43_0 <= LT)||LA43_0==MONKEYS_AT||(LA43_0 >= NATIVE && LA43_0 <= NEW)||LA43_0==NULL||LA43_0==PLUS||(LA43_0 >= PLUSPLUS && LA43_0 <= PUBLIC)||LA43_0==RETURN||(LA43_0 >= SEMI && LA43_0 <= SHORT)||(LA43_0 >= STATIC && LA43_0 <= SUB)||(LA43_0 >= SUBSUB && LA43_0 <= SYNCHRONIZED)||(LA43_0 >= THIS && LA43_0 <= THROW)||(LA43_0 >= TILDE && LA43_0 <= TRY)||(LA43_0 >= VOID && LA43_0 <= WHILE)) ) {
                            alt43=1;
                        }


                        switch (alt43) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:564:10: blockStatement
                    	    {
                    	    pushFollow(FOLLOW_blockStatement_in_methodDeclaration2405);
                    	    blockStatement119=blockStatement();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) stream_blockStatement.add(blockStatement119.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop43;
                        }
                    } while (true);


                    char_literal120=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_methodDeclaration2426); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_RBRACE.add(char_literal120);


                    // AST REWRITE
                    // elements: modifiers, qualifiedNameList, IDENTIFIER, formalParameters, typeParameters
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 567:9: -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( NAME IDENTIFIER ) ^( PARA formalParameters ) ( ^( THROWS qualifiedNameList ) )? )
                    {
                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:567:12: ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( NAME IDENTIFIER ) ^( PARA formalParameters ) ( ^( THROWS qualifiedNameList ) )? )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(METHOD, "METHOD")
                        , root_1);

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:567:21: ( ^( MODIFIER modifiers ) )*
                        while ( stream_modifiers.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:567:21: ^( MODIFIER modifiers )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(MODIFIER, "MODIFIER")
                            , root_2);

                            adaptor.addChild(root_2, stream_modifiers.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_modifiers.reset();

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:567:44: ( ^( TYPE typeParameters ) )?
                        if ( stream_typeParameters.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:567:44: ^( TYPE typeParameters )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(TYPE, "TYPE")
                            , root_2);

                            adaptor.addChild(root_2, stream_typeParameters.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_typeParameters.reset();

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:567:68: ^( NAME IDENTIFIER )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(NAME, "NAME")
                        , root_2);

                        adaptor.addChild(root_2, 
                        stream_IDENTIFIER.nextNode()
                        );

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:567:87: ^( PARA formalParameters )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(PARA, "PARA")
                        , root_2);

                        adaptor.addChild(root_2, stream_formalParameters.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:567:112: ( ^( THROWS qualifiedNameList ) )?
                        if ( stream_qualifiedNameList.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:567:112: ^( THROWS qualifiedNameList )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(THROWS, "THROWS")
                            , root_2);

                            adaptor.addChild(root_2, stream_qualifiedNameList.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_qualifiedNameList.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:568:9: modifiers ( typeParameters )? type IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' )
                    {
                    pushFollow(FOLLOW_modifiers_in_methodDeclaration2483);
                    modifiers121=modifiers();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_modifiers.add(modifiers121.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:569:9: ( typeParameters )?
                    int alt44=2;
                    int LA44_0 = input.LA(1);

                    if ( (LA44_0==LT) ) {
                        alt44=1;
                    }
                    switch (alt44) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:569:10: typeParameters
                            {
                            pushFollow(FOLLOW_typeParameters_in_methodDeclaration2494);
                            typeParameters122=typeParameters();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_typeParameters.add(typeParameters122.getTree());

                            }
                            break;

                    }


                    pushFollow(FOLLOW_type_in_methodDeclaration2515);
                    type123=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_type.add(type123.getTree());

                    IDENTIFIER124=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration2525); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER124);


                    pushFollow(FOLLOW_formalParameters_in_methodDeclaration2535);
                    formalParameters125=formalParameters();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_formalParameters.add(formalParameters125.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:574:9: ( '[' ']' )*
                    loop45:
                    do {
                        int alt45=2;
                        int LA45_0 = input.LA(1);

                        if ( (LA45_0==LBRACKET) ) {
                            alt45=1;
                        }


                        switch (alt45) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:574:10: '[' ']'
                    	    {
                    	    char_literal126=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_methodDeclaration2546); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_LBRACKET.add(char_literal126);


                    	    char_literal127=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_methodDeclaration2548); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_RBRACKET.add(char_literal127);


                    	    }
                    	    break;

                    	default :
                    	    break loop45;
                        }
                    } while (true);


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:576:9: ( 'throws' qualifiedNameList )?
                    int alt46=2;
                    int LA46_0 = input.LA(1);

                    if ( (LA46_0==THROWS) ) {
                        alt46=1;
                    }
                    switch (alt46) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:576:10: 'throws' qualifiedNameList
                            {
                            string_literal128=(Token)match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration2570); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_THROWS.add(string_literal128);


                            pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration2572);
                            qualifiedNameList129=qualifiedNameList();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_qualifiedNameList.add(qualifiedNameList129.getTree());

                            }
                            break;

                    }


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:578:9: ( block | ';' )
                    int alt47=2;
                    int LA47_0 = input.LA(1);

                    if ( (LA47_0==LBRACE) ) {
                        alt47=1;
                    }
                    else if ( (LA47_0==SEMI) ) {
                        alt47=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 47, 0, input);

                        throw nvae;

                    }
                    switch (alt47) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:579:13: block
                            {
                            pushFollow(FOLLOW_block_in_methodDeclaration2627);
                            block130=block();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_block.add(block130.getTree());

                            }
                            break;
                        case 2 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:580:13: ';'
                            {
                            char_literal131=(Token)match(input,SEMI,FOLLOW_SEMI_in_methodDeclaration2641); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_SEMI.add(char_literal131);


                            }
                            break;

                    }


                    // AST REWRITE
                    // elements: LBRACKET, type, RBRACKET, typeParameters, IDENTIFIER, modifiers, qualifiedNameList, formalParameters
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 582:9: -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN type ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? )
                    {
                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:582:12: ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN type ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(METHOD, "METHOD")
                        , root_1);

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:582:21: ( ^( MODIFIER modifiers ) )*
                        while ( stream_modifiers.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:582:21: ^( MODIFIER modifiers )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(MODIFIER, "MODIFIER")
                            , root_2);

                            adaptor.addChild(root_2, stream_modifiers.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_modifiers.reset();

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:582:44: ( ^( TYPE typeParameters ) )?
                        if ( stream_typeParameters.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:582:44: ^( TYPE typeParameters )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(TYPE, "TYPE")
                            , root_2);

                            adaptor.addChild(root_2, stream_typeParameters.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_typeParameters.reset();

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:582:68: ^( RETURN type )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(RETURN, "RETURN")
                        , root_2);

                        adaptor.addChild(root_2, stream_type.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:582:83: ^( NAME IDENTIFIER )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(NAME, "NAME")
                        , root_2);

                        adaptor.addChild(root_2, 
                        stream_IDENTIFIER.nextNode()
                        );

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:582:102: ^( PARA formalParameters ( '[' ']' )* )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(PARA, "PARA")
                        , root_2);

                        adaptor.addChild(root_2, stream_formalParameters.nextTree());

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:582:126: ( '[' ']' )*
                        while ( stream_LBRACKET.hasNext()||stream_RBRACKET.hasNext() ) {
                            adaptor.addChild(root_2, 
                            stream_LBRACKET.nextNode()
                            );

                            adaptor.addChild(root_2, 
                            stream_RBRACKET.nextNode()
                            );

                        }
                        stream_LBRACKET.reset();
                        stream_RBRACKET.reset();

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:582:138: ( ^( THROWS qualifiedNameList ) )?
                        if ( stream_qualifiedNameList.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:582:138: ^( THROWS qualifiedNameList )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(THROWS, "THROWS")
                            , root_2);

                            adaptor.addChild(root_2, stream_qualifiedNameList.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_qualifiedNameList.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:583:9: modifiers ( typeParameters )? 'void' IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' )
                    {
                    pushFollow(FOLLOW_modifiers_in_methodDeclaration2722);
                    modifiers132=modifiers();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_modifiers.add(modifiers132.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:584:9: ( typeParameters )?
                    int alt48=2;
                    int LA48_0 = input.LA(1);

                    if ( (LA48_0==LT) ) {
                        alt48=1;
                    }
                    switch (alt48) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:584:10: typeParameters
                            {
                            pushFollow(FOLLOW_typeParameters_in_methodDeclaration2733);
                            typeParameters133=typeParameters();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_typeParameters.add(typeParameters133.getTree());

                            }
                            break;

                    }


                    string_literal134=(Token)match(input,VOID,FOLLOW_VOID_in_methodDeclaration2754); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_VOID.add(string_literal134);


                    IDENTIFIER135=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodDeclaration2764); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER135);


                    pushFollow(FOLLOW_formalParameters_in_methodDeclaration2774);
                    formalParameters136=formalParameters();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_formalParameters.add(formalParameters136.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:589:9: ( '[' ']' )*
                    loop49:
                    do {
                        int alt49=2;
                        int LA49_0 = input.LA(1);

                        if ( (LA49_0==LBRACKET) ) {
                            alt49=1;
                        }


                        switch (alt49) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:589:10: '[' ']'
                    	    {
                    	    char_literal137=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_methodDeclaration2785); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_LBRACKET.add(char_literal137);


                    	    char_literal138=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_methodDeclaration2787); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_RBRACKET.add(char_literal138);


                    	    }
                    	    break;

                    	default :
                    	    break loop49;
                        }
                    } while (true);


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:591:9: ( 'throws' qualifiedNameList )?
                    int alt50=2;
                    int LA50_0 = input.LA(1);

                    if ( (LA50_0==THROWS) ) {
                        alt50=1;
                    }
                    switch (alt50) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:591:10: 'throws' qualifiedNameList
                            {
                            string_literal139=(Token)match(input,THROWS,FOLLOW_THROWS_in_methodDeclaration2809); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_THROWS.add(string_literal139);


                            pushFollow(FOLLOW_qualifiedNameList_in_methodDeclaration2811);
                            qualifiedNameList140=qualifiedNameList();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_qualifiedNameList.add(qualifiedNameList140.getTree());

                            }
                            break;

                    }


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:593:9: ( block | ';' )
                    int alt51=2;
                    int LA51_0 = input.LA(1);

                    if ( (LA51_0==LBRACE) ) {
                        alt51=1;
                    }
                    else if ( (LA51_0==SEMI) ) {
                        alt51=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 51, 0, input);

                        throw nvae;

                    }
                    switch (alt51) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:594:13: block
                            {
                            pushFollow(FOLLOW_block_in_methodDeclaration2866);
                            block141=block();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_block.add(block141.getTree());

                            }
                            break;
                        case 2 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:595:13: ';'
                            {
                            char_literal142=(Token)match(input,SEMI,FOLLOW_SEMI_in_methodDeclaration2880); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_SEMI.add(char_literal142);


                            }
                            break;

                    }


                    // AST REWRITE
                    // elements: IDENTIFIER, RBRACKET, qualifiedNameList, formalParameters, LBRACKET, VOID, typeParameters, modifiers
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 597:9: -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN 'void' ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? )
                    {
                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:597:12: ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN 'void' ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(METHOD, "METHOD")
                        , root_1);

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:597:21: ( ^( MODIFIER modifiers ) )*
                        while ( stream_modifiers.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:597:21: ^( MODIFIER modifiers )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(MODIFIER, "MODIFIER")
                            , root_2);

                            adaptor.addChild(root_2, stream_modifiers.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_modifiers.reset();

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:597:44: ( ^( TYPE typeParameters ) )?
                        if ( stream_typeParameters.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:597:44: ^( TYPE typeParameters )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(TYPE, "TYPE")
                            , root_2);

                            adaptor.addChild(root_2, stream_typeParameters.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_typeParameters.reset();

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:597:68: ^( RETURN 'void' )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(RETURN, "RETURN")
                        , root_2);

                        adaptor.addChild(root_2, 
                        stream_VOID.nextNode()
                        );

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:597:85: ^( NAME IDENTIFIER )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(NAME, "NAME")
                        , root_2);

                        adaptor.addChild(root_2, 
                        stream_IDENTIFIER.nextNode()
                        );

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:597:104: ^( PARA formalParameters ( '[' ']' )* )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(PARA, "PARA")
                        , root_2);

                        adaptor.addChild(root_2, stream_formalParameters.nextTree());

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:597:128: ( '[' ']' )*
                        while ( stream_RBRACKET.hasNext()||stream_LBRACKET.hasNext() ) {
                            adaptor.addChild(root_2, 
                            stream_LBRACKET.nextNode()
                            );

                            adaptor.addChild(root_2, 
                            stream_RBRACKET.nextNode()
                            );

                        }
                        stream_RBRACKET.reset();
                        stream_LBRACKET.reset();

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:597:140: ( ^( THROWS qualifiedNameList ) )?
                        if ( stream_qualifiedNameList.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:597:140: ^( THROWS qualifiedNameList )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(THROWS, "THROWS")
                            , root_2);

                            adaptor.addChild(root_2, stream_qualifiedNameList.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_qualifiedNameList.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 26, methodDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "methodDeclaration"


    public static class fieldDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "fieldDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:601:1: fieldDeclaration : modifiers type variableDeclarator ( ',' variableDeclarator )* ';' -> ^( FIELD ( ^( MODIFIER modifiers ) )* type ^( VARIABLE variableDeclarator ( variableDeclarator )* ) ) ;
    public final JavaTreeParser.fieldDeclaration_return fieldDeclaration() throws RecognitionException {
        JavaTreeParser.fieldDeclaration_return retval = new JavaTreeParser.fieldDeclaration_return();
        retval.start = input.LT(1);

        int fieldDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal146=null;
        Token char_literal148=null;
        JavaTreeParser.modifiers_return modifiers143 =null;

        JavaTreeParser.type_return type144 =null;

        JavaTreeParser.variableDeclarator_return variableDeclarator145 =null;

        JavaTreeParser.variableDeclarator_return variableDeclarator147 =null;


        Object char_literal146_tree=null;
        Object char_literal148_tree=null;
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
        RewriteRuleSubtreeStream stream_variableDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule variableDeclarator");
        RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
        RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 27) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:602:5: ( modifiers type variableDeclarator ( ',' variableDeclarator )* ';' -> ^( FIELD ( ^( MODIFIER modifiers ) )* type ^( VARIABLE variableDeclarator ( variableDeclarator )* ) ) )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:602:9: modifiers type variableDeclarator ( ',' variableDeclarator )* ';'
            {
            pushFollow(FOLLOW_modifiers_in_fieldDeclaration2972);
            modifiers143=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_modifiers.add(modifiers143.getTree());

            pushFollow(FOLLOW_type_in_fieldDeclaration2982);
            type144=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_type.add(type144.getTree());

            pushFollow(FOLLOW_variableDeclarator_in_fieldDeclaration2992);
            variableDeclarator145=variableDeclarator();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_variableDeclarator.add(variableDeclarator145.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:605:9: ( ',' variableDeclarator )*
            loop53:
            do {
                int alt53=2;
                int LA53_0 = input.LA(1);

                if ( (LA53_0==COMMA) ) {
                    alt53=1;
                }


                switch (alt53) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:605:10: ',' variableDeclarator
            	    {
            	    char_literal146=(Token)match(input,COMMA,FOLLOW_COMMA_in_fieldDeclaration3003); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_COMMA.add(char_literal146);


            	    pushFollow(FOLLOW_variableDeclarator_in_fieldDeclaration3005);
            	    variableDeclarator147=variableDeclarator();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_variableDeclarator.add(variableDeclarator147.getTree());

            	    }
            	    break;

            	default :
            	    break loop53;
                }
            } while (true);


            char_literal148=(Token)match(input,SEMI,FOLLOW_SEMI_in_fieldDeclaration3026); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_SEMI.add(char_literal148);


            // AST REWRITE
            // elements: type, variableDeclarator, modifiers, variableDeclarator
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 608:9: -> ^( FIELD ( ^( MODIFIER modifiers ) )* type ^( VARIABLE variableDeclarator ( variableDeclarator )* ) )
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:608:12: ^( FIELD ( ^( MODIFIER modifiers ) )* type ^( VARIABLE variableDeclarator ( variableDeclarator )* ) )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(FIELD, "FIELD")
                , root_1);

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:608:20: ( ^( MODIFIER modifiers ) )*
                while ( stream_modifiers.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:608:20: ^( MODIFIER modifiers )
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot(
                    (Object)adaptor.create(MODIFIER, "MODIFIER")
                    , root_2);

                    adaptor.addChild(root_2, stream_modifiers.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_modifiers.reset();

                adaptor.addChild(root_1, stream_type.nextTree());

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:608:48: ^( VARIABLE variableDeclarator ( variableDeclarator )* )
                {
                Object root_2 = (Object)adaptor.nil();
                root_2 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(VARIABLE, "VARIABLE")
                , root_2);

                adaptor.addChild(root_2, stream_variableDeclarator.nextTree());

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:608:78: ( variableDeclarator )*
                while ( stream_variableDeclarator.hasNext() ) {
                    adaptor.addChild(root_2, stream_variableDeclarator.nextTree());

                }
                stream_variableDeclarator.reset();

                adaptor.addChild(root_1, root_2);
                }

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 27, fieldDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "fieldDeclaration"


    public static class variableDeclarator_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "variableDeclarator"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:611:1: variableDeclarator : IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )? -> ( '[' ']' )* IDENTIFIER ;
    public final JavaTreeParser.variableDeclarator_return variableDeclarator() throws RecognitionException {
        JavaTreeParser.variableDeclarator_return retval = new JavaTreeParser.variableDeclarator_return();
        retval.start = input.LT(1);

        int variableDeclarator_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER149=null;
        Token char_literal150=null;
        Token char_literal151=null;
        Token char_literal152=null;
        JavaTreeParser.variableInitializer_return variableInitializer153 =null;


        Object IDENTIFIER149_tree=null;
        Object char_literal150_tree=null;
        Object char_literal151_tree=null;
        Object char_literal152_tree=null;
        RewriteRuleTokenStream stream_LBRACKET=new RewriteRuleTokenStream(adaptor,"token LBRACKET");
        RewriteRuleTokenStream stream_RBRACKET=new RewriteRuleTokenStream(adaptor,"token RBRACKET");
        RewriteRuleTokenStream stream_EQ=new RewriteRuleTokenStream(adaptor,"token EQ");
        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
        RewriteRuleSubtreeStream stream_variableInitializer=new RewriteRuleSubtreeStream(adaptor,"rule variableInitializer");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 28) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:612:5: ( IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )? -> ( '[' ']' )* IDENTIFIER )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:612:9: IDENTIFIER ( '[' ']' )* ( '=' variableInitializer )?
            {
            IDENTIFIER149=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_variableDeclarator3078); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER149);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:613:9: ( '[' ']' )*
            loop54:
            do {
                int alt54=2;
                int LA54_0 = input.LA(1);

                if ( (LA54_0==LBRACKET) ) {
                    alt54=1;
                }


                switch (alt54) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:613:10: '[' ']'
            	    {
            	    char_literal150=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_variableDeclarator3089); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_LBRACKET.add(char_literal150);


            	    char_literal151=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_variableDeclarator3091); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_RBRACKET.add(char_literal151);


            	    }
            	    break;

            	default :
            	    break loop54;
                }
            } while (true);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:615:9: ( '=' variableInitializer )?
            int alt55=2;
            int LA55_0 = input.LA(1);

            if ( (LA55_0==EQ) ) {
                alt55=1;
            }
            switch (alt55) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:615:10: '=' variableInitializer
                    {
                    char_literal152=(Token)match(input,EQ,FOLLOW_EQ_in_variableDeclarator3113); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_EQ.add(char_literal152);


                    pushFollow(FOLLOW_variableInitializer_in_variableDeclarator3115);
                    variableInitializer153=variableInitializer();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_variableInitializer.add(variableInitializer153.getTree());

                    }
                    break;

            }


            // AST REWRITE
            // elements: IDENTIFIER, RBRACKET, LBRACKET
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 617:9: -> ( '[' ']' )* IDENTIFIER
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:618:9: ( '[' ']' )*
                while ( stream_RBRACKET.hasNext()||stream_LBRACKET.hasNext() ) {
                    adaptor.addChild(root_0, 
                    stream_LBRACKET.nextNode()
                    );

                    adaptor.addChild(root_0, 
                    stream_RBRACKET.nextNode()
                    );

                }
                stream_RBRACKET.reset();
                stream_LBRACKET.reset();

                adaptor.addChild(root_0, 
                stream_IDENTIFIER.nextNode()
                );

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 28, variableDeclarator_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "variableDeclarator"


    public static class interfaceBodyDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "interfaceBodyDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:624:1: interfaceBodyDeclaration : ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' );
    public final JavaTreeParser.interfaceBodyDeclaration_return interfaceBodyDeclaration() throws RecognitionException {
        JavaTreeParser.interfaceBodyDeclaration_return retval = new JavaTreeParser.interfaceBodyDeclaration_return();
        retval.start = input.LT(1);

        int interfaceBodyDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal158=null;
        JavaTreeParser.interfaceFieldDeclaration_return interfaceFieldDeclaration154 =null;

        JavaTreeParser.interfaceMethodDeclaration_return interfaceMethodDeclaration155 =null;

        JavaTreeParser.interfaceDeclaration_return interfaceDeclaration156 =null;

        JavaTreeParser.classDeclaration_return classDeclaration157 =null;


        Object char_literal158_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 29) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:625:5: ( interfaceFieldDeclaration | interfaceMethodDeclaration | interfaceDeclaration | classDeclaration | ';' )
            int alt56=5;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA56_1 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else if ( (synpred74_JavaTree()) ) {
                    alt56=3;
                }
                else if ( (synpred75_JavaTree()) ) {
                    alt56=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA56_2 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else if ( (synpred74_JavaTree()) ) {
                    alt56=3;
                }
                else if ( (synpred75_JavaTree()) ) {
                    alt56=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA56_3 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else if ( (synpred74_JavaTree()) ) {
                    alt56=3;
                }
                else if ( (synpred75_JavaTree()) ) {
                    alt56=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA56_4 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else if ( (synpred74_JavaTree()) ) {
                    alt56=3;
                }
                else if ( (synpred75_JavaTree()) ) {
                    alt56=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA56_5 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else if ( (synpred74_JavaTree()) ) {
                    alt56=3;
                }
                else if ( (synpred75_JavaTree()) ) {
                    alt56=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA56_6 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else if ( (synpred74_JavaTree()) ) {
                    alt56=3;
                }
                else if ( (synpred75_JavaTree()) ) {
                    alt56=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA56_7 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else if ( (synpred74_JavaTree()) ) {
                    alt56=3;
                }
                else if ( (synpred75_JavaTree()) ) {
                    alt56=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA56_8 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else if ( (synpred74_JavaTree()) ) {
                    alt56=3;
                }
                else if ( (synpred75_JavaTree()) ) {
                    alt56=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA56_9 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else if ( (synpred74_JavaTree()) ) {
                    alt56=3;
                }
                else if ( (synpred75_JavaTree()) ) {
                    alt56=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA56_10 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else if ( (synpred74_JavaTree()) ) {
                    alt56=3;
                }
                else if ( (synpred75_JavaTree()) ) {
                    alt56=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA56_11 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else if ( (synpred74_JavaTree()) ) {
                    alt56=3;
                }
                else if ( (synpred75_JavaTree()) ) {
                    alt56=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA56_12 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else if ( (synpred74_JavaTree()) ) {
                    alt56=3;
                }
                else if ( (synpred75_JavaTree()) ) {
                    alt56=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 12, input);

                    throw nvae;

                }
                }
                break;
            case IDENTIFIER:
                {
                int LA56_13 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 13, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case INT:
            case LONG:
            case SHORT:
                {
                int LA56_14 = input.LA(2);

                if ( (synpred72_JavaTree()) ) {
                    alt56=1;
                }
                else if ( (synpred73_JavaTree()) ) {
                    alt56=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 56, 14, input);

                    throw nvae;

                }
                }
                break;
            case LT:
            case VOID:
                {
                alt56=2;
                }
                break;
            case INTERFACE:
                {
                alt56=3;
                }
                break;
            case CLASS:
            case ENUM:
                {
                alt56=4;
                }
                break;
            case SEMI:
                {
                alt56=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 56, 0, input);

                throw nvae;

            }

            switch (alt56) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:626:9: interfaceFieldDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_interfaceFieldDeclaration_in_interfaceBodyDeclaration3181);
                    interfaceFieldDeclaration154=interfaceFieldDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, interfaceFieldDeclaration154.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:627:9: interfaceMethodDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_interfaceMethodDeclaration_in_interfaceBodyDeclaration3191);
                    interfaceMethodDeclaration155=interfaceMethodDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, interfaceMethodDeclaration155.getTree());

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:628:9: interfaceDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_interfaceDeclaration_in_interfaceBodyDeclaration3201);
                    interfaceDeclaration156=interfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, interfaceDeclaration156.getTree());

                    }
                    break;
                case 4 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:629:9: classDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_classDeclaration_in_interfaceBodyDeclaration3211);
                    classDeclaration157=classDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, classDeclaration157.getTree());

                    }
                    break;
                case 5 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:630:9: ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal158=(Token)match(input,SEMI,FOLLOW_SEMI_in_interfaceBodyDeclaration3221); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal158_tree = 
                    (Object)adaptor.create(char_literal158)
                    ;
                    adaptor.addChild(root_0, char_literal158_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 29, interfaceBodyDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "interfaceBodyDeclaration"


    public static class interfaceMethodDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "interfaceMethodDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:633:1: interfaceMethodDeclaration : ( modifiers ( typeParameters )? 'void' IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN 'void' ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? ) | modifiers ( typeParameters )? type IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN type ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? ) );
    public final JavaTreeParser.interfaceMethodDeclaration_return interfaceMethodDeclaration() throws RecognitionException {
        JavaTreeParser.interfaceMethodDeclaration_return retval = new JavaTreeParser.interfaceMethodDeclaration_return();
        retval.start = input.LT(1);

        int interfaceMethodDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal161=null;
        Token IDENTIFIER162=null;
        Token char_literal164=null;
        Token char_literal165=null;
        Token string_literal166=null;
        Token char_literal168=null;
        Token IDENTIFIER172=null;
        Token char_literal174=null;
        Token char_literal175=null;
        Token string_literal176=null;
        Token char_literal178=null;
        JavaTreeParser.modifiers_return modifiers159 =null;

        JavaTreeParser.typeParameters_return typeParameters160 =null;

        JavaTreeParser.formalParameters_return formalParameters163 =null;

        JavaTreeParser.qualifiedNameList_return qualifiedNameList167 =null;

        JavaTreeParser.modifiers_return modifiers169 =null;

        JavaTreeParser.typeParameters_return typeParameters170 =null;

        JavaTreeParser.type_return type171 =null;

        JavaTreeParser.formalParameters_return formalParameters173 =null;

        JavaTreeParser.qualifiedNameList_return qualifiedNameList177 =null;


        Object string_literal161_tree=null;
        Object IDENTIFIER162_tree=null;
        Object char_literal164_tree=null;
        Object char_literal165_tree=null;
        Object string_literal166_tree=null;
        Object char_literal168_tree=null;
        Object IDENTIFIER172_tree=null;
        Object char_literal174_tree=null;
        Object char_literal175_tree=null;
        Object string_literal176_tree=null;
        Object char_literal178_tree=null;
        RewriteRuleTokenStream stream_LBRACKET=new RewriteRuleTokenStream(adaptor,"token LBRACKET");
        RewriteRuleTokenStream stream_THROWS=new RewriteRuleTokenStream(adaptor,"token THROWS");
        RewriteRuleTokenStream stream_VOID=new RewriteRuleTokenStream(adaptor,"token VOID");
        RewriteRuleTokenStream stream_RBRACKET=new RewriteRuleTokenStream(adaptor,"token RBRACKET");
        RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
        RewriteRuleSubtreeStream stream_typeParameters=new RewriteRuleSubtreeStream(adaptor,"rule typeParameters");
        RewriteRuleSubtreeStream stream_formalParameters=new RewriteRuleSubtreeStream(adaptor,"rule formalParameters");
        RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
        RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
        RewriteRuleSubtreeStream stream_qualifiedNameList=new RewriteRuleSubtreeStream(adaptor,"rule qualifiedNameList");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 30) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:634:5: ( modifiers ( typeParameters )? 'void' IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN 'void' ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? ) | modifiers ( typeParameters )? type IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN type ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? ) )
            int alt63=2;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA63_1 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA63_2 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA63_3 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA63_4 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA63_5 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA63_6 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA63_7 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA63_8 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA63_9 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA63_10 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA63_11 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA63_12 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 12, input);

                    throw nvae;

                }
                }
                break;
            case LT:
                {
                int LA63_13 = input.LA(2);

                if ( (synpred79_JavaTree()) ) {
                    alt63=1;
                }
                else if ( (true) ) {
                    alt63=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 63, 13, input);

                    throw nvae;

                }
                }
                break;
            case VOID:
                {
                alt63=1;
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case IDENTIFIER:
            case INT:
            case LONG:
            case SHORT:
                {
                alt63=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 63, 0, input);

                throw nvae;

            }

            switch (alt63) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:634:9: modifiers ( typeParameters )? 'void' IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';'
                    {
                    pushFollow(FOLLOW_modifiers_in_interfaceMethodDeclaration3241);
                    modifiers159=modifiers();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_modifiers.add(modifiers159.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:635:9: ( typeParameters )?
                    int alt57=2;
                    int LA57_0 = input.LA(1);

                    if ( (LA57_0==LT) ) {
                        alt57=1;
                    }
                    switch (alt57) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:635:10: typeParameters
                            {
                            pushFollow(FOLLOW_typeParameters_in_interfaceMethodDeclaration3252);
                            typeParameters160=typeParameters();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_typeParameters.add(typeParameters160.getTree());

                            }
                            break;

                    }


                    string_literal161=(Token)match(input,VOID,FOLLOW_VOID_in_interfaceMethodDeclaration3273); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_VOID.add(string_literal161);


                    IDENTIFIER162=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration3283); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER162);


                    pushFollow(FOLLOW_formalParameters_in_interfaceMethodDeclaration3293);
                    formalParameters163=formalParameters();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_formalParameters.add(formalParameters163.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:640:9: ( '[' ']' )*
                    loop58:
                    do {
                        int alt58=2;
                        int LA58_0 = input.LA(1);

                        if ( (LA58_0==LBRACKET) ) {
                            alt58=1;
                        }


                        switch (alt58) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:640:10: '[' ']'
                    	    {
                    	    char_literal164=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_interfaceMethodDeclaration3304); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_LBRACKET.add(char_literal164);


                    	    char_literal165=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_interfaceMethodDeclaration3306); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_RBRACKET.add(char_literal165);


                    	    }
                    	    break;

                    	default :
                    	    break loop58;
                        }
                    } while (true);


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:642:9: ( 'throws' qualifiedNameList )?
                    int alt59=2;
                    int LA59_0 = input.LA(1);

                    if ( (LA59_0==THROWS) ) {
                        alt59=1;
                    }
                    switch (alt59) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:642:10: 'throws' qualifiedNameList
                            {
                            string_literal166=(Token)match(input,THROWS,FOLLOW_THROWS_in_interfaceMethodDeclaration3328); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_THROWS.add(string_literal166);


                            pushFollow(FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration3330);
                            qualifiedNameList167=qualifiedNameList();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_qualifiedNameList.add(qualifiedNameList167.getTree());

                            }
                            break;

                    }


                    char_literal168=(Token)match(input,SEMI,FOLLOW_SEMI_in_interfaceMethodDeclaration3343); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_SEMI.add(char_literal168);


                    // AST REWRITE
                    // elements: VOID, RBRACKET, IDENTIFIER, qualifiedNameList, LBRACKET, typeParameters, modifiers, formalParameters
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 644:9: -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN 'void' ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? )
                    {
                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:644:11: ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN 'void' ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(METHOD, "METHOD")
                        , root_1);

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:644:20: ( ^( MODIFIER modifiers ) )*
                        while ( stream_modifiers.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:644:20: ^( MODIFIER modifiers )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(MODIFIER, "MODIFIER")
                            , root_2);

                            adaptor.addChild(root_2, stream_modifiers.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_modifiers.reset();

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:644:43: ( ^( TYPE typeParameters ) )?
                        if ( stream_typeParameters.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:644:43: ^( TYPE typeParameters )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(TYPE, "TYPE")
                            , root_2);

                            adaptor.addChild(root_2, stream_typeParameters.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_typeParameters.reset();

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:644:67: ^( RETURN 'void' )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(RETURN, "RETURN")
                        , root_2);

                        adaptor.addChild(root_2, 
                        stream_VOID.nextNode()
                        );

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:644:84: ^( NAME IDENTIFIER )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(NAME, "NAME")
                        , root_2);

                        adaptor.addChild(root_2, 
                        stream_IDENTIFIER.nextNode()
                        );

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:644:103: ^( PARA formalParameters ( '[' ']' )* )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(PARA, "PARA")
                        , root_2);

                        adaptor.addChild(root_2, stream_formalParameters.nextTree());

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:644:127: ( '[' ']' )*
                        while ( stream_RBRACKET.hasNext()||stream_LBRACKET.hasNext() ) {
                            adaptor.addChild(root_2, 
                            stream_LBRACKET.nextNode()
                            );

                            adaptor.addChild(root_2, 
                            stream_RBRACKET.nextNode()
                            );

                        }
                        stream_RBRACKET.reset();
                        stream_LBRACKET.reset();

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:644:139: ( ^( THROWS qualifiedNameList ) )?
                        if ( stream_qualifiedNameList.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:644:139: ^( THROWS qualifiedNameList )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(THROWS, "THROWS")
                            , root_2);

                            adaptor.addChild(root_2, stream_qualifiedNameList.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_qualifiedNameList.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:646:9: modifiers ( typeParameters )? type IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';'
                    {
                    pushFollow(FOLLOW_modifiers_in_interfaceMethodDeclaration3423);
                    modifiers169=modifiers();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_modifiers.add(modifiers169.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:647:9: ( typeParameters )?
                    int alt60=2;
                    int LA60_0 = input.LA(1);

                    if ( (LA60_0==LT) ) {
                        alt60=1;
                    }
                    switch (alt60) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:647:10: typeParameters
                            {
                            pushFollow(FOLLOW_typeParameters_in_interfaceMethodDeclaration3434);
                            typeParameters170=typeParameters();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_typeParameters.add(typeParameters170.getTree());

                            }
                            break;

                    }


                    pushFollow(FOLLOW_type_in_interfaceMethodDeclaration3455);
                    type171=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_type.add(type171.getTree());

                    IDENTIFIER172=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration3465); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER172);


                    pushFollow(FOLLOW_formalParameters_in_interfaceMethodDeclaration3475);
                    formalParameters173=formalParameters();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_formalParameters.add(formalParameters173.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:652:9: ( '[' ']' )*
                    loop61:
                    do {
                        int alt61=2;
                        int LA61_0 = input.LA(1);

                        if ( (LA61_0==LBRACKET) ) {
                            alt61=1;
                        }


                        switch (alt61) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:652:10: '[' ']'
                    	    {
                    	    char_literal174=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_interfaceMethodDeclaration3486); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_LBRACKET.add(char_literal174);


                    	    char_literal175=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_interfaceMethodDeclaration3488); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_RBRACKET.add(char_literal175);


                    	    }
                    	    break;

                    	default :
                    	    break loop61;
                        }
                    } while (true);


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:654:9: ( 'throws' qualifiedNameList )?
                    int alt62=2;
                    int LA62_0 = input.LA(1);

                    if ( (LA62_0==THROWS) ) {
                        alt62=1;
                    }
                    switch (alt62) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:654:10: 'throws' qualifiedNameList
                            {
                            string_literal176=(Token)match(input,THROWS,FOLLOW_THROWS_in_interfaceMethodDeclaration3510); if (state.failed) return retval; 
                            if ( state.backtracking==0 ) stream_THROWS.add(string_literal176);


                            pushFollow(FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration3512);
                            qualifiedNameList177=qualifiedNameList();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_qualifiedNameList.add(qualifiedNameList177.getTree());

                            }
                            break;

                    }


                    char_literal178=(Token)match(input,SEMI,FOLLOW_SEMI_in_interfaceMethodDeclaration3525); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_SEMI.add(char_literal178);


                    // AST REWRITE
                    // elements: LBRACKET, typeParameters, modifiers, IDENTIFIER, formalParameters, qualifiedNameList, RBRACKET, type
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 656:9: -> ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN type ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? )
                    {
                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:656:11: ^( METHOD ( ^( MODIFIER modifiers ) )* ( ^( TYPE typeParameters ) )? ^( RETURN type ) ^( NAME IDENTIFIER ) ^( PARA formalParameters ( '[' ']' )* ) ( ^( THROWS qualifiedNameList ) )? )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(METHOD, "METHOD")
                        , root_1);

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:656:20: ( ^( MODIFIER modifiers ) )*
                        while ( stream_modifiers.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:656:20: ^( MODIFIER modifiers )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(MODIFIER, "MODIFIER")
                            , root_2);

                            adaptor.addChild(root_2, stream_modifiers.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_modifiers.reset();

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:656:43: ( ^( TYPE typeParameters ) )?
                        if ( stream_typeParameters.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:656:43: ^( TYPE typeParameters )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(TYPE, "TYPE")
                            , root_2);

                            adaptor.addChild(root_2, stream_typeParameters.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_typeParameters.reset();

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:656:67: ^( RETURN type )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(RETURN, "RETURN")
                        , root_2);

                        adaptor.addChild(root_2, stream_type.nextTree());

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:656:82: ^( NAME IDENTIFIER )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(NAME, "NAME")
                        , root_2);

                        adaptor.addChild(root_2, 
                        stream_IDENTIFIER.nextNode()
                        );

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:656:101: ^( PARA formalParameters ( '[' ']' )* )
                        {
                        Object root_2 = (Object)adaptor.nil();
                        root_2 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(PARA, "PARA")
                        , root_2);

                        adaptor.addChild(root_2, stream_formalParameters.nextTree());

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:656:125: ( '[' ']' )*
                        while ( stream_LBRACKET.hasNext()||stream_RBRACKET.hasNext() ) {
                            adaptor.addChild(root_2, 
                            stream_LBRACKET.nextNode()
                            );

                            adaptor.addChild(root_2, 
                            stream_RBRACKET.nextNode()
                            );

                        }
                        stream_LBRACKET.reset();
                        stream_RBRACKET.reset();

                        adaptor.addChild(root_1, root_2);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:656:137: ( ^( THROWS qualifiedNameList ) )?
                        if ( stream_qualifiedNameList.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:656:137: ^( THROWS qualifiedNameList )
                            {
                            Object root_2 = (Object)adaptor.nil();
                            root_2 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(THROWS, "THROWS")
                            , root_2);

                            adaptor.addChild(root_2, stream_qualifiedNameList.nextTree());

                            adaptor.addChild(root_1, root_2);
                            }

                        }
                        stream_qualifiedNameList.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 30, interfaceMethodDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "interfaceMethodDeclaration"


    public static class interfaceFieldDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "interfaceFieldDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:664:1: interfaceFieldDeclaration : modifiers type variableDeclarator ( ',' variableDeclarator )* ';' -> ^( FIELD ( ^( MODIFIER modifiers ) )* type ^( VARIABLE variableDeclarator ( variableDeclarator )* ) ) ;
    public final JavaTreeParser.interfaceFieldDeclaration_return interfaceFieldDeclaration() throws RecognitionException {
        JavaTreeParser.interfaceFieldDeclaration_return retval = new JavaTreeParser.interfaceFieldDeclaration_return();
        retval.start = input.LT(1);

        int interfaceFieldDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal182=null;
        Token char_literal184=null;
        JavaTreeParser.modifiers_return modifiers179 =null;

        JavaTreeParser.type_return type180 =null;

        JavaTreeParser.variableDeclarator_return variableDeclarator181 =null;

        JavaTreeParser.variableDeclarator_return variableDeclarator183 =null;


        Object char_literal182_tree=null;
        Object char_literal184_tree=null;
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
        RewriteRuleSubtreeStream stream_variableDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule variableDeclarator");
        RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
        RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:665:5: ( modifiers type variableDeclarator ( ',' variableDeclarator )* ';' -> ^( FIELD ( ^( MODIFIER modifiers ) )* type ^( VARIABLE variableDeclarator ( variableDeclarator )* ) ) )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:665:9: modifiers type variableDeclarator ( ',' variableDeclarator )* ';'
            {
            pushFollow(FOLLOW_modifiers_in_interfaceFieldDeclaration3606);
            modifiers179=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_modifiers.add(modifiers179.getTree());

            pushFollow(FOLLOW_type_in_interfaceFieldDeclaration3608);
            type180=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_type.add(type180.getTree());

            pushFollow(FOLLOW_variableDeclarator_in_interfaceFieldDeclaration3610);
            variableDeclarator181=variableDeclarator();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_variableDeclarator.add(variableDeclarator181.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:666:9: ( ',' variableDeclarator )*
            loop64:
            do {
                int alt64=2;
                int LA64_0 = input.LA(1);

                if ( (LA64_0==COMMA) ) {
                    alt64=1;
                }


                switch (alt64) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:666:10: ',' variableDeclarator
            	    {
            	    char_literal182=(Token)match(input,COMMA,FOLLOW_COMMA_in_interfaceFieldDeclaration3621); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_COMMA.add(char_literal182);


            	    pushFollow(FOLLOW_variableDeclarator_in_interfaceFieldDeclaration3623);
            	    variableDeclarator183=variableDeclarator();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_variableDeclarator.add(variableDeclarator183.getTree());

            	    }
            	    break;

            	default :
            	    break loop64;
                }
            } while (true);


            char_literal184=(Token)match(input,SEMI,FOLLOW_SEMI_in_interfaceFieldDeclaration3644); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_SEMI.add(char_literal184);


            // AST REWRITE
            // elements: variableDeclarator, variableDeclarator, modifiers, type
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 669:9: -> ^( FIELD ( ^( MODIFIER modifiers ) )* type ^( VARIABLE variableDeclarator ( variableDeclarator )* ) )
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:670:9: ^( FIELD ( ^( MODIFIER modifiers ) )* type ^( VARIABLE variableDeclarator ( variableDeclarator )* ) )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(FIELD, "FIELD")
                , root_1);

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:670:17: ( ^( MODIFIER modifiers ) )*
                while ( stream_modifiers.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:670:17: ^( MODIFIER modifiers )
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot(
                    (Object)adaptor.create(MODIFIER, "MODIFIER")
                    , root_2);

                    adaptor.addChild(root_2, stream_modifiers.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_modifiers.reset();

                adaptor.addChild(root_1, stream_type.nextTree());

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:670:45: ^( VARIABLE variableDeclarator ( variableDeclarator )* )
                {
                Object root_2 = (Object)adaptor.nil();
                root_2 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(VARIABLE, "VARIABLE")
                , root_2);

                adaptor.addChild(root_2, stream_variableDeclarator.nextTree());

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:670:75: ( variableDeclarator )*
                while ( stream_variableDeclarator.hasNext() ) {
                    adaptor.addChild(root_2, stream_variableDeclarator.nextTree());

                }
                stream_variableDeclarator.reset();

                adaptor.addChild(root_1, root_2);
                }

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 31, interfaceFieldDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "interfaceFieldDeclaration"


    public static class type_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "type"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:674:1: type : ( classOrInterfaceType ( '[' ']' )* -> ^( TYPE classOrInterfaceType ( '[' ']' )* ) | primitiveType ( '[' ']' )* -> ^( TYPE primitiveType ( '[' ']' )* ) );
    public final JavaTreeParser.type_return type() throws RecognitionException {
        JavaTreeParser.type_return retval = new JavaTreeParser.type_return();
        retval.start = input.LT(1);

        int type_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal186=null;
        Token char_literal187=null;
        Token char_literal189=null;
        Token char_literal190=null;
        JavaTreeParser.classOrInterfaceType_return classOrInterfaceType185 =null;

        JavaTreeParser.primitiveType_return primitiveType188 =null;


        Object char_literal186_tree=null;
        Object char_literal187_tree=null;
        Object char_literal189_tree=null;
        Object char_literal190_tree=null;
        RewriteRuleTokenStream stream_LBRACKET=new RewriteRuleTokenStream(adaptor,"token LBRACKET");
        RewriteRuleTokenStream stream_RBRACKET=new RewriteRuleTokenStream(adaptor,"token RBRACKET");
        RewriteRuleSubtreeStream stream_primitiveType=new RewriteRuleSubtreeStream(adaptor,"rule primitiveType");
        RewriteRuleSubtreeStream stream_classOrInterfaceType=new RewriteRuleSubtreeStream(adaptor,"rule classOrInterfaceType");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 32) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:675:5: ( classOrInterfaceType ( '[' ']' )* -> ^( TYPE classOrInterfaceType ( '[' ']' )* ) | primitiveType ( '[' ']' )* -> ^( TYPE primitiveType ( '[' ']' )* ) )
            int alt67=2;
            int LA67_0 = input.LA(1);

            if ( (LA67_0==IDENTIFIER) ) {
                alt67=1;
            }
            else if ( (LA67_0==BOOLEAN||LA67_0==BYTE||LA67_0==CHAR||LA67_0==DOUBLE||LA67_0==FLOAT||LA67_0==INT||LA67_0==LONG||LA67_0==SHORT) ) {
                alt67=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 67, 0, input);

                throw nvae;

            }
            switch (alt67) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:675:9: classOrInterfaceType ( '[' ']' )*
                    {
                    pushFollow(FOLLOW_classOrInterfaceType_in_type3705);
                    classOrInterfaceType185=classOrInterfaceType();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_classOrInterfaceType.add(classOrInterfaceType185.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:676:9: ( '[' ']' )*
                    loop65:
                    do {
                        int alt65=2;
                        int LA65_0 = input.LA(1);

                        if ( (LA65_0==LBRACKET) ) {
                            alt65=1;
                        }


                        switch (alt65) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:676:10: '[' ']'
                    	    {
                    	    char_literal186=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_type3716); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_LBRACKET.add(char_literal186);


                    	    char_literal187=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_type3718); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_RBRACKET.add(char_literal187);


                    	    }
                    	    break;

                    	default :
                    	    break loop65;
                        }
                    } while (true);


                    // AST REWRITE
                    // elements: RBRACKET, LBRACKET, classOrInterfaceType
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 678:9: -> ^( TYPE classOrInterfaceType ( '[' ']' )* )
                    {
                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:678:12: ^( TYPE classOrInterfaceType ( '[' ']' )* )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(TYPE, "TYPE")
                        , root_1);

                        adaptor.addChild(root_1, stream_classOrInterfaceType.nextTree());

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:678:40: ( '[' ']' )*
                        while ( stream_RBRACKET.hasNext()||stream_LBRACKET.hasNext() ) {
                            adaptor.addChild(root_1, 
                            stream_LBRACKET.nextNode()
                            );

                            adaptor.addChild(root_1, 
                            stream_RBRACKET.nextNode()
                            );

                        }
                        stream_RBRACKET.reset();
                        stream_LBRACKET.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:679:9: primitiveType ( '[' ']' )*
                    {
                    pushFollow(FOLLOW_primitiveType_in_type3762);
                    primitiveType188=primitiveType();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_primitiveType.add(primitiveType188.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:680:9: ( '[' ']' )*
                    loop66:
                    do {
                        int alt66=2;
                        int LA66_0 = input.LA(1);

                        if ( (LA66_0==LBRACKET) ) {
                            alt66=1;
                        }


                        switch (alt66) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:680:10: '[' ']'
                    	    {
                    	    char_literal189=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_type3773); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_LBRACKET.add(char_literal189);


                    	    char_literal190=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_type3775); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_RBRACKET.add(char_literal190);


                    	    }
                    	    break;

                    	default :
                    	    break loop66;
                        }
                    } while (true);


                    // AST REWRITE
                    // elements: RBRACKET, LBRACKET, primitiveType
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 682:9: -> ^( TYPE primitiveType ( '[' ']' )* )
                    {
                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:682:12: ^( TYPE primitiveType ( '[' ']' )* )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(TYPE, "TYPE")
                        , root_1);

                        adaptor.addChild(root_1, stream_primitiveType.nextTree());

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:682:33: ( '[' ']' )*
                        while ( stream_RBRACKET.hasNext()||stream_LBRACKET.hasNext() ) {
                            adaptor.addChild(root_1, 
                            stream_LBRACKET.nextNode()
                            );

                            adaptor.addChild(root_1, 
                            stream_RBRACKET.nextNode()
                            );

                        }
                        stream_RBRACKET.reset();
                        stream_LBRACKET.reset();

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 32, type_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "type"


    public static class classOrInterfaceType_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "classOrInterfaceType"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:686:1: classOrInterfaceType : IDENTIFIER ( typeArguments | '<' '>' )? ( '.' IDENTIFIER ( typeArguments | '<' '>' )? )* ;
    public final JavaTreeParser.classOrInterfaceType_return classOrInterfaceType() throws RecognitionException {
        JavaTreeParser.classOrInterfaceType_return retval = new JavaTreeParser.classOrInterfaceType_return();
        retval.start = input.LT(1);

        int classOrInterfaceType_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER191=null;
        Token char_literal193=null;
        Token char_literal194=null;
        Token char_literal195=null;
        Token IDENTIFIER196=null;
        Token char_literal198=null;
        Token char_literal199=null;
        JavaTreeParser.typeArguments_return typeArguments192 =null;

        JavaTreeParser.typeArguments_return typeArguments197 =null;


        Object IDENTIFIER191_tree=null;
        Object char_literal193_tree=null;
        Object char_literal194_tree=null;
        Object char_literal195_tree=null;
        Object IDENTIFIER196_tree=null;
        Object char_literal198_tree=null;
        Object char_literal199_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 33) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:687:5: ( IDENTIFIER ( typeArguments | '<' '>' )? ( '.' IDENTIFIER ( typeArguments | '<' '>' )? )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:687:9: IDENTIFIER ( typeArguments | '<' '>' )? ( '.' IDENTIFIER ( typeArguments | '<' '>' )? )*
            {
            root_0 = (Object)adaptor.nil();


            IDENTIFIER191=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classOrInterfaceType3830); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER191_tree = 
            (Object)adaptor.create(IDENTIFIER191)
            ;
            adaptor.addChild(root_0, IDENTIFIER191_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:688:9: ( typeArguments | '<' '>' )?
            int alt68=3;
            int LA68_0 = input.LA(1);

            if ( (LA68_0==LT) ) {
                int LA68_1 = input.LA(2);

                if ( (LA68_1==GT) ) {
                    alt68=2;
                }
                else if ( (LA68_1==BOOLEAN||LA68_1==BYTE||LA68_1==CHAR||LA68_1==DOUBLE||LA68_1==FLOAT||LA68_1==IDENTIFIER||LA68_1==INT||LA68_1==LONG||LA68_1==QUES||LA68_1==SHORT) ) {
                    alt68=1;
                }
            }
            switch (alt68) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:688:10: typeArguments
                    {
                    pushFollow(FOLLOW_typeArguments_in_classOrInterfaceType3841);
                    typeArguments192=typeArguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, typeArguments192.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:688:26: '<' '>'
                    {
                    char_literal193=(Token)match(input,LT,FOLLOW_LT_in_classOrInterfaceType3845); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal193_tree = 
                    (Object)adaptor.create(char_literal193)
                    ;
                    adaptor.addChild(root_0, char_literal193_tree);
                    }

                    char_literal194=(Token)match(input,GT,FOLLOW_GT_in_classOrInterfaceType3847); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal194_tree = 
                    (Object)adaptor.create(char_literal194)
                    ;
                    adaptor.addChild(root_0, char_literal194_tree);
                    }

                    }
                    break;

            }


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:690:9: ( '.' IDENTIFIER ( typeArguments | '<' '>' )? )*
            loop70:
            do {
                int alt70=2;
                int LA70_0 = input.LA(1);

                if ( (LA70_0==DOT) ) {
                    alt70=1;
                }


                switch (alt70) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:690:10: '.' IDENTIFIER ( typeArguments | '<' '>' )?
            	    {
            	    char_literal195=(Token)match(input,DOT,FOLLOW_DOT_in_classOrInterfaceType3869); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal195_tree = 
            	    (Object)adaptor.create(char_literal195)
            	    ;
            	    adaptor.addChild(root_0, char_literal195_tree);
            	    }

            	    IDENTIFIER196=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classOrInterfaceType3871); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    IDENTIFIER196_tree = 
            	    (Object)adaptor.create(IDENTIFIER196)
            	    ;
            	    adaptor.addChild(root_0, IDENTIFIER196_tree);
            	    }

            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:691:13: ( typeArguments | '<' '>' )?
            	    int alt69=3;
            	    int LA69_0 = input.LA(1);

            	    if ( (LA69_0==LT) ) {
            	        int LA69_1 = input.LA(2);

            	        if ( (LA69_1==GT) ) {
            	            alt69=2;
            	        }
            	        else if ( (LA69_1==BOOLEAN||LA69_1==BYTE||LA69_1==CHAR||LA69_1==DOUBLE||LA69_1==FLOAT||LA69_1==IDENTIFIER||LA69_1==INT||LA69_1==LONG||LA69_1==QUES||LA69_1==SHORT) ) {
            	            alt69=1;
            	        }
            	    }
            	    switch (alt69) {
            	        case 1 :
            	            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:691:14: typeArguments
            	            {
            	            pushFollow(FOLLOW_typeArguments_in_classOrInterfaceType3886);
            	            typeArguments197=typeArguments();

            	            state._fsp--;
            	            if (state.failed) return retval;
            	            if ( state.backtracking==0 ) adaptor.addChild(root_0, typeArguments197.getTree());

            	            }
            	            break;
            	        case 2 :
            	            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:691:30: '<' '>'
            	            {
            	            char_literal198=(Token)match(input,LT,FOLLOW_LT_in_classOrInterfaceType3890); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            char_literal198_tree = 
            	            (Object)adaptor.create(char_literal198)
            	            ;
            	            adaptor.addChild(root_0, char_literal198_tree);
            	            }

            	            char_literal199=(Token)match(input,GT,FOLLOW_GT_in_classOrInterfaceType3892); if (state.failed) return retval;
            	            if ( state.backtracking==0 ) {
            	            char_literal199_tree = 
            	            (Object)adaptor.create(char_literal199)
            	            ;
            	            adaptor.addChild(root_0, char_literal199_tree);
            	            }

            	            }
            	            break;

            	    }


            	    }
            	    break;

            	default :
            	    break loop70;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 33, classOrInterfaceType_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "classOrInterfaceType"


    public static class primitiveType_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "primitiveType"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:696:1: primitiveType : ( 'boolean' | 'char' | 'byte' | 'short' | 'int' | 'long' | 'float' | 'double' );
    public final JavaTreeParser.primitiveType_return primitiveType() throws RecognitionException {
        JavaTreeParser.primitiveType_return retval = new JavaTreeParser.primitiveType_return();
        retval.start = input.LT(1);

        int primitiveType_StartIndex = input.index();

        Object root_0 = null;

        Token set200=null;

        Object set200_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 34) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:697:5: ( 'boolean' | 'char' | 'byte' | 'short' | 'int' | 'long' | 'float' | 'double' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:
            {
            root_0 = (Object)adaptor.nil();


            set200=(Token)input.LT(1);

            if ( input.LA(1)==BOOLEAN||input.LA(1)==BYTE||input.LA(1)==CHAR||input.LA(1)==DOUBLE||input.LA(1)==FLOAT||input.LA(1)==INT||input.LA(1)==LONG||input.LA(1)==SHORT ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                (Object)adaptor.create(set200)
                );
                state.errorRecovery=false;
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 34, primitiveType_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "primitiveType"


    public static class typeArguments_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "typeArguments"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:707:1: typeArguments : '<' typeArgument ( ',' typeArgument )* '>' -> ^( TYPE_ARG typeArgument ( typeArgument )* ) ;
    public final JavaTreeParser.typeArguments_return typeArguments() throws RecognitionException {
        JavaTreeParser.typeArguments_return retval = new JavaTreeParser.typeArguments_return();
        retval.start = input.LT(1);

        int typeArguments_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal201=null;
        Token char_literal203=null;
        Token char_literal205=null;
        JavaTreeParser.typeArgument_return typeArgument202 =null;

        JavaTreeParser.typeArgument_return typeArgument204 =null;


        Object char_literal201_tree=null;
        Object char_literal203_tree=null;
        Object char_literal205_tree=null;
        RewriteRuleTokenStream stream_GT=new RewriteRuleTokenStream(adaptor,"token GT");
        RewriteRuleTokenStream stream_LT=new RewriteRuleTokenStream(adaptor,"token LT");
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_typeArgument=new RewriteRuleSubtreeStream(adaptor,"rule typeArgument");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 35) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:708:5: ( '<' typeArgument ( ',' typeArgument )* '>' -> ^( TYPE_ARG typeArgument ( typeArgument )* ) )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:708:9: '<' typeArgument ( ',' typeArgument )* '>'
            {
            char_literal201=(Token)match(input,LT,FOLLOW_LT_in_typeArguments4029); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_LT.add(char_literal201);


            pushFollow(FOLLOW_typeArgument_in_typeArguments4031);
            typeArgument202=typeArgument();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_typeArgument.add(typeArgument202.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:709:9: ( ',' typeArgument )*
            loop71:
            do {
                int alt71=2;
                int LA71_0 = input.LA(1);

                if ( (LA71_0==COMMA) ) {
                    alt71=1;
                }


                switch (alt71) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:709:10: ',' typeArgument
            	    {
            	    char_literal203=(Token)match(input,COMMA,FOLLOW_COMMA_in_typeArguments4042); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_COMMA.add(char_literal203);


            	    pushFollow(FOLLOW_typeArgument_in_typeArguments4044);
            	    typeArgument204=typeArgument();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_typeArgument.add(typeArgument204.getTree());

            	    }
            	    break;

            	default :
            	    break loop71;
                }
            } while (true);


            char_literal205=(Token)match(input,GT,FOLLOW_GT_in_typeArguments4066); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_GT.add(char_literal205);


            // AST REWRITE
            // elements: typeArgument, typeArgument
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 712:9: -> ^( TYPE_ARG typeArgument ( typeArgument )* )
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:712:12: ^( TYPE_ARG typeArgument ( typeArgument )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(TYPE_ARG, "TYPE_ARG")
                , root_1);

                adaptor.addChild(root_1, stream_typeArgument.nextTree());

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:712:36: ( typeArgument )*
                while ( stream_typeArgument.hasNext() ) {
                    adaptor.addChild(root_1, stream_typeArgument.nextTree());

                }
                stream_typeArgument.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 35, typeArguments_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "typeArguments"


    public static class typeArgument_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "typeArgument"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:715:1: typeArgument : ( type | '?' ( ( 'extends' | 'super' ) type )? );
    public final JavaTreeParser.typeArgument_return typeArgument() throws RecognitionException {
        JavaTreeParser.typeArgument_return retval = new JavaTreeParser.typeArgument_return();
        retval.start = input.LT(1);

        int typeArgument_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal207=null;
        Token set208=null;
        JavaTreeParser.type_return type206 =null;

        JavaTreeParser.type_return type209 =null;


        Object char_literal207_tree=null;
        Object set208_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 36) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:716:5: ( type | '?' ( ( 'extends' | 'super' ) type )? )
            int alt73=2;
            int LA73_0 = input.LA(1);

            if ( (LA73_0==BOOLEAN||LA73_0==BYTE||LA73_0==CHAR||LA73_0==DOUBLE||LA73_0==FLOAT||LA73_0==IDENTIFIER||LA73_0==INT||LA73_0==LONG||LA73_0==SHORT) ) {
                alt73=1;
            }
            else if ( (LA73_0==QUES) ) {
                alt73=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 73, 0, input);

                throw nvae;

            }
            switch (alt73) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:716:9: type
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_type_in_typeArgument4105);
                    type206=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, type206.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:717:9: '?' ( ( 'extends' | 'super' ) type )?
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal207=(Token)match(input,QUES,FOLLOW_QUES_in_typeArgument4115); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal207_tree = 
                    (Object)adaptor.create(char_literal207)
                    ;
                    adaptor.addChild(root_0, char_literal207_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:718:9: ( ( 'extends' | 'super' ) type )?
                    int alt72=2;
                    int LA72_0 = input.LA(1);

                    if ( (LA72_0==EXTENDS||LA72_0==SUPER) ) {
                        alt72=1;
                    }
                    switch (alt72) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:719:13: ( 'extends' | 'super' ) type
                            {
                            set208=(Token)input.LT(1);

                            if ( input.LA(1)==EXTENDS||input.LA(1)==SUPER ) {
                                input.consume();
                                if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                                (Object)adaptor.create(set208)
                                );
                                state.errorRecovery=false;
                                state.failed=false;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return retval;}
                                MismatchedSetException mse = new MismatchedSetException(null,input);
                                throw mse;
                            }


                            pushFollow(FOLLOW_type_in_typeArgument4183);
                            type209=type();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, type209.getTree());

                            }
                            break;

                    }


                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 36, typeArgument_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "typeArgument"


    public static class qualifiedNameList_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "qualifiedNameList"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:726:1: qualifiedNameList : qualifiedName ( ',' qualifiedName )* -> ^( TYPE qualifiedName ) ( ^( TYPE qualifiedName ) )* ;
    public final JavaTreeParser.qualifiedNameList_return qualifiedNameList() throws RecognitionException {
        JavaTreeParser.qualifiedNameList_return retval = new JavaTreeParser.qualifiedNameList_return();
        retval.start = input.LT(1);

        int qualifiedNameList_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal211=null;
        JavaTreeParser.qualifiedName_return qualifiedName210 =null;

        JavaTreeParser.qualifiedName_return qualifiedName212 =null;


        Object char_literal211_tree=null;
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_qualifiedName=new RewriteRuleSubtreeStream(adaptor,"rule qualifiedName");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 37) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:727:5: ( qualifiedName ( ',' qualifiedName )* -> ^( TYPE qualifiedName ) ( ^( TYPE qualifiedName ) )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:727:9: qualifiedName ( ',' qualifiedName )*
            {
            pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList4214);
            qualifiedName210=qualifiedName();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_qualifiedName.add(qualifiedName210.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:728:9: ( ',' qualifiedName )*
            loop74:
            do {
                int alt74=2;
                int LA74_0 = input.LA(1);

                if ( (LA74_0==COMMA) ) {
                    alt74=1;
                }


                switch (alt74) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:728:10: ',' qualifiedName
            	    {
            	    char_literal211=(Token)match(input,COMMA,FOLLOW_COMMA_in_qualifiedNameList4225); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_COMMA.add(char_literal211);


            	    pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList4227);
            	    qualifiedName212=qualifiedName();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_qualifiedName.add(qualifiedName212.getTree());

            	    }
            	    break;

            	default :
            	    break loop74;
                }
            } while (true);


            // AST REWRITE
            // elements: qualifiedName, qualifiedName
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 730:9: -> ^( TYPE qualifiedName ) ( ^( TYPE qualifiedName ) )*
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:731:9: ^( TYPE qualifiedName )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(TYPE, "TYPE")
                , root_1);

                adaptor.addChild(root_1, stream_qualifiedName.nextTree());

                adaptor.addChild(root_0, root_1);
                }

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:731:31: ( ^( TYPE qualifiedName ) )*
                while ( stream_qualifiedName.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:731:31: ^( TYPE qualifiedName )
                    {
                    Object root_1 = (Object)adaptor.nil();
                    root_1 = (Object)adaptor.becomeRoot(
                    (Object)adaptor.create(TYPE, "TYPE")
                    , root_1);

                    adaptor.addChild(root_1, stream_qualifiedName.nextTree());

                    adaptor.addChild(root_0, root_1);
                    }

                }
                stream_qualifiedName.reset();

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 37, qualifiedNameList_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "qualifiedNameList"


    public static class formalParameters_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "formalParameters"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:734:1: formalParameters : '(' ( formalParameterDecls )? ')' ;
    public final JavaTreeParser.formalParameters_return formalParameters() throws RecognitionException {
        JavaTreeParser.formalParameters_return retval = new JavaTreeParser.formalParameters_return();
        retval.start = input.LT(1);

        int formalParameters_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal213=null;
        Token char_literal215=null;
        JavaTreeParser.formalParameterDecls_return formalParameterDecls214 =null;


        Object char_literal213_tree=null;
        Object char_literal215_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 38) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:735:5: ( '(' ( formalParameterDecls )? ')' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:735:9: '(' ( formalParameterDecls )? ')'
            {
            root_0 = (Object)adaptor.nil();


            char_literal213=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_formalParameters4289); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal213_tree = 
            (Object)adaptor.create(char_literal213)
            ;
            adaptor.addChild(root_0, char_literal213_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:736:9: ( formalParameterDecls )?
            int alt75=2;
            int LA75_0 = input.LA(1);

            if ( (LA75_0==BOOLEAN||LA75_0==BYTE||LA75_0==CHAR||LA75_0==DOUBLE||LA75_0==FINAL||LA75_0==FLOAT||LA75_0==IDENTIFIER||LA75_0==INT||LA75_0==LONG||LA75_0==MONKEYS_AT||LA75_0==SHORT) ) {
                alt75=1;
            }
            switch (alt75) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:736:10: formalParameterDecls
                    {
                    pushFollow(FOLLOW_formalParameterDecls_in_formalParameters4300);
                    formalParameterDecls214=formalParameterDecls();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, formalParameterDecls214.getTree());

                    }
                    break;

            }


            char_literal215=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_formalParameters4322); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal215_tree = 
            (Object)adaptor.create(char_literal215)
            ;
            adaptor.addChild(root_0, char_literal215_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 38, formalParameters_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "formalParameters"


    public static class formalParameterDecls_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "formalParameterDecls"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:741:1: formalParameterDecls : ( ellipsisParameterDecl -> ^( ELLIPSIS_PARA ellipsisParameterDecl ) | normalParameterDecl ( ',' normalParameterDecl )* -> ^( NORMAL_PARA normalParameterDecl ) ( ^( NORMAL_PARA normalParameterDecl ) )* | ( normalParameterDecl ',' )+ ellipsisParameterDecl -> ( ^( NORMAL_PARA normalParameterDecl ) )+ ^( ELLIPSIS_PARA ellipsisParameterDecl ) );
    public final JavaTreeParser.formalParameterDecls_return formalParameterDecls() throws RecognitionException {
        JavaTreeParser.formalParameterDecls_return retval = new JavaTreeParser.formalParameterDecls_return();
        retval.start = input.LT(1);

        int formalParameterDecls_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal218=null;
        Token char_literal221=null;
        JavaTreeParser.ellipsisParameterDecl_return ellipsisParameterDecl216 =null;

        JavaTreeParser.normalParameterDecl_return normalParameterDecl217 =null;

        JavaTreeParser.normalParameterDecl_return normalParameterDecl219 =null;

        JavaTreeParser.normalParameterDecl_return normalParameterDecl220 =null;

        JavaTreeParser.ellipsisParameterDecl_return ellipsisParameterDecl222 =null;


        Object char_literal218_tree=null;
        Object char_literal221_tree=null;
        RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
        RewriteRuleSubtreeStream stream_ellipsisParameterDecl=new RewriteRuleSubtreeStream(adaptor,"rule ellipsisParameterDecl");
        RewriteRuleSubtreeStream stream_normalParameterDecl=new RewriteRuleSubtreeStream(adaptor,"rule normalParameterDecl");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 39) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:742:5: ( ellipsisParameterDecl -> ^( ELLIPSIS_PARA ellipsisParameterDecl ) | normalParameterDecl ( ',' normalParameterDecl )* -> ^( NORMAL_PARA normalParameterDecl ) ( ^( NORMAL_PARA normalParameterDecl ) )* | ( normalParameterDecl ',' )+ ellipsisParameterDecl -> ( ^( NORMAL_PARA normalParameterDecl ) )+ ^( ELLIPSIS_PARA ellipsisParameterDecl ) )
            int alt78=3;
            switch ( input.LA(1) ) {
            case FINAL:
                {
                int LA78_1 = input.LA(2);

                if ( (synpred105_JavaTree()) ) {
                    alt78=1;
                }
                else if ( (synpred107_JavaTree()) ) {
                    alt78=2;
                }
                else if ( (true) ) {
                    alt78=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 78, 1, input);

                    throw nvae;

                }
                }
                break;
            case MONKEYS_AT:
                {
                int LA78_2 = input.LA(2);

                if ( (synpred105_JavaTree()) ) {
                    alt78=1;
                }
                else if ( (synpred107_JavaTree()) ) {
                    alt78=2;
                }
                else if ( (true) ) {
                    alt78=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 78, 2, input);

                    throw nvae;

                }
                }
                break;
            case IDENTIFIER:
                {
                int LA78_3 = input.LA(2);

                if ( (synpred105_JavaTree()) ) {
                    alt78=1;
                }
                else if ( (synpred107_JavaTree()) ) {
                    alt78=2;
                }
                else if ( (true) ) {
                    alt78=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 78, 3, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case INT:
            case LONG:
            case SHORT:
                {
                int LA78_4 = input.LA(2);

                if ( (synpred105_JavaTree()) ) {
                    alt78=1;
                }
                else if ( (synpred107_JavaTree()) ) {
                    alt78=2;
                }
                else if ( (true) ) {
                    alt78=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 78, 4, input);

                    throw nvae;

                }
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 78, 0, input);

                throw nvae;

            }

            switch (alt78) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:742:9: ellipsisParameterDecl
                    {
                    pushFollow(FOLLOW_ellipsisParameterDecl_in_formalParameterDecls4342);
                    ellipsisParameterDecl216=ellipsisParameterDecl();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_ellipsisParameterDecl.add(ellipsisParameterDecl216.getTree());

                    // AST REWRITE
                    // elements: ellipsisParameterDecl
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 742:31: -> ^( ELLIPSIS_PARA ellipsisParameterDecl )
                    {
                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:742:34: ^( ELLIPSIS_PARA ellipsisParameterDecl )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(ELLIPSIS_PARA, "ELLIPSIS_PARA")
                        , root_1);

                        adaptor.addChild(root_1, stream_ellipsisParameterDecl.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:743:9: normalParameterDecl ( ',' normalParameterDecl )*
                    {
                    pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls4360);
                    normalParameterDecl217=normalParameterDecl();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_normalParameterDecl.add(normalParameterDecl217.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:744:9: ( ',' normalParameterDecl )*
                    loop76:
                    do {
                        int alt76=2;
                        int LA76_0 = input.LA(1);

                        if ( (LA76_0==COMMA) ) {
                            alt76=1;
                        }


                        switch (alt76) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:744:10: ',' normalParameterDecl
                    	    {
                    	    char_literal218=(Token)match(input,COMMA,FOLLOW_COMMA_in_formalParameterDecls4371); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_COMMA.add(char_literal218);


                    	    pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls4373);
                    	    normalParameterDecl219=normalParameterDecl();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) stream_normalParameterDecl.add(normalParameterDecl219.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop76;
                        }
                    } while (true);


                    // AST REWRITE
                    // elements: normalParameterDecl, normalParameterDecl
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 746:9: -> ^( NORMAL_PARA normalParameterDecl ) ( ^( NORMAL_PARA normalParameterDecl ) )*
                    {
                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:747:9: ^( NORMAL_PARA normalParameterDecl )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(NORMAL_PARA, "NORMAL_PARA")
                        , root_1);

                        adaptor.addChild(root_1, stream_normalParameterDecl.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:747:44: ( ^( NORMAL_PARA normalParameterDecl ) )*
                        while ( stream_normalParameterDecl.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:747:44: ^( NORMAL_PARA normalParameterDecl )
                            {
                            Object root_1 = (Object)adaptor.nil();
                            root_1 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(NORMAL_PARA, "NORMAL_PARA")
                            , root_1);

                            adaptor.addChild(root_1, stream_normalParameterDecl.nextTree());

                            adaptor.addChild(root_0, root_1);
                            }

                        }
                        stream_normalParameterDecl.reset();

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:748:9: ( normalParameterDecl ',' )+ ellipsisParameterDecl
                    {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:748:9: ( normalParameterDecl ',' )+
                    int cnt77=0;
                    loop77:
                    do {
                        int alt77=2;
                        switch ( input.LA(1) ) {
                        case FINAL:
                            {
                            int LA77_1 = input.LA(2);

                            if ( (synpred108_JavaTree()) ) {
                                alt77=1;
                            }


                            }
                            break;
                        case MONKEYS_AT:
                            {
                            int LA77_2 = input.LA(2);

                            if ( (synpred108_JavaTree()) ) {
                                alt77=1;
                            }


                            }
                            break;
                        case IDENTIFIER:
                            {
                            int LA77_3 = input.LA(2);

                            if ( (synpred108_JavaTree()) ) {
                                alt77=1;
                            }


                            }
                            break;
                        case BOOLEAN:
                        case BYTE:
                        case CHAR:
                        case DOUBLE:
                        case FLOAT:
                        case INT:
                        case LONG:
                        case SHORT:
                            {
                            int LA77_4 = input.LA(2);

                            if ( (synpred108_JavaTree()) ) {
                                alt77=1;
                            }


                            }
                            break;

                        }

                        switch (alt77) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:748:10: normalParameterDecl ','
                    	    {
                    	    pushFollow(FOLLOW_normalParameterDecl_in_formalParameterDecls4426);
                    	    normalParameterDecl220=normalParameterDecl();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) stream_normalParameterDecl.add(normalParameterDecl220.getTree());

                    	    char_literal221=(Token)match(input,COMMA,FOLLOW_COMMA_in_formalParameterDecls4436); if (state.failed) return retval; 
                    	    if ( state.backtracking==0 ) stream_COMMA.add(char_literal221);


                    	    }
                    	    break;

                    	default :
                    	    if ( cnt77 >= 1 ) break loop77;
                    	    if (state.backtracking>0) {state.failed=true; return retval;}
                                EarlyExitException eee =
                                    new EarlyExitException(77, input);
                                throw eee;
                        }
                        cnt77++;
                    } while (true);


                    pushFollow(FOLLOW_ellipsisParameterDecl_in_formalParameterDecls4458);
                    ellipsisParameterDecl222=ellipsisParameterDecl();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_ellipsisParameterDecl.add(ellipsisParameterDecl222.getTree());

                    // AST REWRITE
                    // elements: ellipsisParameterDecl, normalParameterDecl
                    // token labels: 
                    // rule labels: retval
                    // token list labels: 
                    // rule list labels: 
                    // wildcard labels: 
                    if ( state.backtracking==0 ) {

                    retval.tree = root_0;
                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

                    root_0 = (Object)adaptor.nil();
                    // 752:9: -> ( ^( NORMAL_PARA normalParameterDecl ) )+ ^( ELLIPSIS_PARA ellipsisParameterDecl )
                    {
                        if ( !(stream_normalParameterDecl.hasNext()) ) {
                            throw new RewriteEarlyExitException();
                        }
                        while ( stream_normalParameterDecl.hasNext() ) {
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:753:9: ^( NORMAL_PARA normalParameterDecl )
                            {
                            Object root_1 = (Object)adaptor.nil();
                            root_1 = (Object)adaptor.becomeRoot(
                            (Object)adaptor.create(NORMAL_PARA, "NORMAL_PARA")
                            , root_1);

                            adaptor.addChild(root_1, stream_normalParameterDecl.nextTree());

                            adaptor.addChild(root_0, root_1);
                            }

                        }
                        stream_normalParameterDecl.reset();

                        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:753:45: ^( ELLIPSIS_PARA ellipsisParameterDecl )
                        {
                        Object root_1 = (Object)adaptor.nil();
                        root_1 = (Object)adaptor.becomeRoot(
                        (Object)adaptor.create(ELLIPSIS_PARA, "ELLIPSIS_PARA")
                        , root_1);

                        adaptor.addChild(root_1, stream_ellipsisParameterDecl.nextTree());

                        adaptor.addChild(root_0, root_1);
                        }

                    }


                    retval.tree = root_0;
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 39, formalParameterDecls_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "formalParameterDecls"


    public static class normalParameterDecl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "normalParameterDecl"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:756:1: normalParameterDecl : variableModifiers type IDENTIFIER ( '[' ']' )* -> ( variableModifiers )* type ( '[' ']' )* IDENTIFIER ;
    public final JavaTreeParser.normalParameterDecl_return normalParameterDecl() throws RecognitionException {
        JavaTreeParser.normalParameterDecl_return retval = new JavaTreeParser.normalParameterDecl_return();
        retval.start = input.LT(1);

        int normalParameterDecl_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER225=null;
        Token char_literal226=null;
        Token char_literal227=null;
        JavaTreeParser.variableModifiers_return variableModifiers223 =null;

        JavaTreeParser.type_return type224 =null;


        Object IDENTIFIER225_tree=null;
        Object char_literal226_tree=null;
        Object char_literal227_tree=null;
        RewriteRuleTokenStream stream_LBRACKET=new RewriteRuleTokenStream(adaptor,"token LBRACKET");
        RewriteRuleTokenStream stream_RBRACKET=new RewriteRuleTokenStream(adaptor,"token RBRACKET");
        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
        RewriteRuleSubtreeStream stream_variableModifiers=new RewriteRuleSubtreeStream(adaptor,"rule variableModifiers");
        RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 40) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:757:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* -> ( variableModifiers )* type ( '[' ']' )* IDENTIFIER )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:757:9: variableModifiers type IDENTIFIER ( '[' ']' )*
            {
            pushFollow(FOLLOW_variableModifiers_in_normalParameterDecl4510);
            variableModifiers223=variableModifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_variableModifiers.add(variableModifiers223.getTree());

            pushFollow(FOLLOW_type_in_normalParameterDecl4512);
            type224=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_type.add(type224.getTree());

            IDENTIFIER225=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_normalParameterDecl4514); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER225);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:758:9: ( '[' ']' )*
            loop79:
            do {
                int alt79=2;
                int LA79_0 = input.LA(1);

                if ( (LA79_0==LBRACKET) ) {
                    alt79=1;
                }


                switch (alt79) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:758:10: '[' ']'
            	    {
            	    char_literal226=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_normalParameterDecl4525); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_LBRACKET.add(char_literal226);


            	    char_literal227=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_normalParameterDecl4527); if (state.failed) return retval; 
            	    if ( state.backtracking==0 ) stream_RBRACKET.add(char_literal227);


            	    }
            	    break;

            	default :
            	    break loop79;
                }
            } while (true);


            // AST REWRITE
            // elements: RBRACKET, variableModifiers, IDENTIFIER, type, LBRACKET
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 760:9: -> ( variableModifiers )* type ( '[' ']' )* IDENTIFIER
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:761:9: ( variableModifiers )*
                while ( stream_variableModifiers.hasNext() ) {
                    adaptor.addChild(root_0, stream_variableModifiers.nextTree());

                }
                stream_variableModifiers.reset();

                adaptor.addChild(root_0, stream_type.nextTree());

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:761:33: ( '[' ']' )*
                while ( stream_RBRACKET.hasNext()||stream_LBRACKET.hasNext() ) {
                    adaptor.addChild(root_0, 
                    stream_LBRACKET.nextNode()
                    );

                    adaptor.addChild(root_0, 
                    stream_RBRACKET.nextNode()
                    );

                }
                stream_RBRACKET.reset();
                stream_LBRACKET.reset();

                adaptor.addChild(root_0, 
                stream_IDENTIFIER.nextNode()
                );

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 40, normalParameterDecl_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "normalParameterDecl"


    public static class ellipsisParameterDecl_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "ellipsisParameterDecl"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:764:1: ellipsisParameterDecl : variableModifiers type '...' IDENTIFIER ;
    public final JavaTreeParser.ellipsisParameterDecl_return ellipsisParameterDecl() throws RecognitionException {
        JavaTreeParser.ellipsisParameterDecl_return retval = new JavaTreeParser.ellipsisParameterDecl_return();
        retval.start = input.LT(1);

        int ellipsisParameterDecl_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal230=null;
        Token IDENTIFIER231=null;
        JavaTreeParser.variableModifiers_return variableModifiers228 =null;

        JavaTreeParser.type_return type229 =null;


        Object string_literal230_tree=null;
        Object IDENTIFIER231_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 41) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:765:5: ( variableModifiers type '...' IDENTIFIER )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:765:9: variableModifiers type '...' IDENTIFIER
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_variableModifiers_in_ellipsisParameterDecl4591);
            variableModifiers228=variableModifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, variableModifiers228.getTree());

            pushFollow(FOLLOW_type_in_ellipsisParameterDecl4601);
            type229=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, type229.getTree());

            string_literal230=(Token)match(input,ELLIPSIS,FOLLOW_ELLIPSIS_in_ellipsisParameterDecl4604); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            string_literal230_tree = 
            (Object)adaptor.create(string_literal230)
            ;
            adaptor.addChild(root_0, string_literal230_tree);
            }

            IDENTIFIER231=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_ellipsisParameterDecl4614); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER231_tree = 
            (Object)adaptor.create(IDENTIFIER231)
            ;
            adaptor.addChild(root_0, IDENTIFIER231_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 41, ellipsisParameterDecl_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "ellipsisParameterDecl"


    public static class explicitConstructorInvocation_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "explicitConstructorInvocation"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:771:1: explicitConstructorInvocation : ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' );
    public final JavaTreeParser.explicitConstructorInvocation_return explicitConstructorInvocation() throws RecognitionException {
        JavaTreeParser.explicitConstructorInvocation_return retval = new JavaTreeParser.explicitConstructorInvocation_return();
        retval.start = input.LT(1);

        int explicitConstructorInvocation_StartIndex = input.index();

        Object root_0 = null;

        Token set233=null;
        Token char_literal235=null;
        Token char_literal237=null;
        Token string_literal239=null;
        Token char_literal241=null;
        JavaTreeParser.nonWildcardTypeArguments_return nonWildcardTypeArguments232 =null;

        JavaTreeParser.arguments_return arguments234 =null;

        JavaTreeParser.primary_return primary236 =null;

        JavaTreeParser.nonWildcardTypeArguments_return nonWildcardTypeArguments238 =null;

        JavaTreeParser.arguments_return arguments240 =null;


        Object set233_tree=null;
        Object char_literal235_tree=null;
        Object char_literal237_tree=null;
        Object string_literal239_tree=null;
        Object char_literal241_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 42) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:772:5: ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' | primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';' )
            int alt82=2;
            switch ( input.LA(1) ) {
            case LT:
                {
                alt82=1;
                }
                break;
            case THIS:
                {
                int LA82_2 = input.LA(2);

                if ( (synpred112_JavaTree()) ) {
                    alt82=1;
                }
                else if ( (true) ) {
                    alt82=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 82, 2, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CHARLITERAL:
            case DOUBLE:
            case DOUBLELITERAL:
            case FALSE:
            case FLOAT:
            case FLOATLITERAL:
            case IDENTIFIER:
            case INT:
            case INTLITERAL:
            case LONG:
            case LONGLITERAL:
            case LPAREN:
            case NEW:
            case NULL:
            case SHORT:
            case STRINGLITERAL:
            case TRUE:
            case VOID:
                {
                alt82=2;
                }
                break;
            case SUPER:
                {
                int LA82_4 = input.LA(2);

                if ( (synpred112_JavaTree()) ) {
                    alt82=1;
                }
                else if ( (true) ) {
                    alt82=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 82, 4, input);

                    throw nvae;

                }
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 82, 0, input);

                throw nvae;

            }

            switch (alt82) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:772:9: ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:772:9: ( nonWildcardTypeArguments )?
                    int alt80=2;
                    int LA80_0 = input.LA(1);

                    if ( (LA80_0==LT) ) {
                        alt80=1;
                    }
                    switch (alt80) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:772:10: nonWildcardTypeArguments
                            {
                            pushFollow(FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation4636);
                            nonWildcardTypeArguments232=nonWildcardTypeArguments();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, nonWildcardTypeArguments232.getTree());

                            }
                            break;

                    }


                    set233=(Token)input.LT(1);

                    if ( input.LA(1)==SUPER||input.LA(1)==THIS ) {
                        input.consume();
                        if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                        (Object)adaptor.create(set233)
                        );
                        state.errorRecovery=false;
                        state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        throw mse;
                    }


                    pushFollow(FOLLOW_arguments_in_explicitConstructorInvocation4694);
                    arguments234=arguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, arguments234.getTree());

                    char_literal235=(Token)match(input,SEMI,FOLLOW_SEMI_in_explicitConstructorInvocation4696); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal235_tree = 
                    (Object)adaptor.create(char_literal235)
                    ;
                    adaptor.addChild(root_0, char_literal235_tree);
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:779:9: primary '.' ( nonWildcardTypeArguments )? 'super' arguments ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_primary_in_explicitConstructorInvocation4707);
                    primary236=primary();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, primary236.getTree());

                    char_literal237=(Token)match(input,DOT,FOLLOW_DOT_in_explicitConstructorInvocation4717); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal237_tree = 
                    (Object)adaptor.create(char_literal237)
                    ;
                    adaptor.addChild(root_0, char_literal237_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:781:9: ( nonWildcardTypeArguments )?
                    int alt81=2;
                    int LA81_0 = input.LA(1);

                    if ( (LA81_0==LT) ) {
                        alt81=1;
                    }
                    switch (alt81) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:781:10: nonWildcardTypeArguments
                            {
                            pushFollow(FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation4728);
                            nonWildcardTypeArguments238=nonWildcardTypeArguments();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, nonWildcardTypeArguments238.getTree());

                            }
                            break;

                    }


                    string_literal239=(Token)match(input,SUPER,FOLLOW_SUPER_in_explicitConstructorInvocation4749); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal239_tree = 
                    (Object)adaptor.create(string_literal239)
                    ;
                    adaptor.addChild(root_0, string_literal239_tree);
                    }

                    pushFollow(FOLLOW_arguments_in_explicitConstructorInvocation4759);
                    arguments240=arguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, arguments240.getTree());

                    char_literal241=(Token)match(input,SEMI,FOLLOW_SEMI_in_explicitConstructorInvocation4761); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal241_tree = 
                    (Object)adaptor.create(char_literal241)
                    ;
                    adaptor.addChild(root_0, char_literal241_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 42, explicitConstructorInvocation_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "explicitConstructorInvocation"


    public static class qualifiedName_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "qualifiedName"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:787:1: qualifiedName : IDENTIFIER ( '.' IDENTIFIER )* ;
    public final JavaTreeParser.qualifiedName_return qualifiedName() throws RecognitionException {
        JavaTreeParser.qualifiedName_return retval = new JavaTreeParser.qualifiedName_return();
        retval.start = input.LT(1);

        int qualifiedName_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER242=null;
        Token char_literal243=null;
        Token IDENTIFIER244=null;

        Object IDENTIFIER242_tree=null;
        Object char_literal243_tree=null;
        Object IDENTIFIER244_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 43) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:788:5: ( IDENTIFIER ( '.' IDENTIFIER )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:788:9: IDENTIFIER ( '.' IDENTIFIER )*
            {
            root_0 = (Object)adaptor.nil();


            IDENTIFIER242=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedName4781); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER242_tree = 
            (Object)adaptor.create(IDENTIFIER242)
            ;
            adaptor.addChild(root_0, IDENTIFIER242_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:789:9: ( '.' IDENTIFIER )*
            loop83:
            do {
                int alt83=2;
                int LA83_0 = input.LA(1);

                if ( (LA83_0==DOT) ) {
                    alt83=1;
                }


                switch (alt83) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:789:10: '.' IDENTIFIER
            	    {
            	    char_literal243=(Token)match(input,DOT,FOLLOW_DOT_in_qualifiedName4792); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal243_tree = 
            	    (Object)adaptor.create(char_literal243)
            	    ;
            	    adaptor.addChild(root_0, char_literal243_tree);
            	    }

            	    IDENTIFIER244=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_qualifiedName4794); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    IDENTIFIER244_tree = 
            	    (Object)adaptor.create(IDENTIFIER244)
            	    ;
            	    adaptor.addChild(root_0, IDENTIFIER244_tree);
            	    }

            	    }
            	    break;

            	default :
            	    break loop83;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 43, qualifiedName_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "qualifiedName"


    public static class annotations_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "annotations"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:793:1: annotations : ( annotation )+ ;
    public final JavaTreeParser.annotations_return annotations() throws RecognitionException {
        JavaTreeParser.annotations_return retval = new JavaTreeParser.annotations_return();
        retval.start = input.LT(1);

        int annotations_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.annotation_return annotation245 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 44) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:794:5: ( ( annotation )+ )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:794:9: ( annotation )+
            {
            root_0 = (Object)adaptor.nil();


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:794:9: ( annotation )+
            int cnt84=0;
            loop84:
            do {
                int alt84=2;
                int LA84_0 = input.LA(1);

                if ( (LA84_0==MONKEYS_AT) ) {
                    alt84=1;
                }


                switch (alt84) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:794:10: annotation
            	    {
            	    pushFollow(FOLLOW_annotation_in_annotations4826);
            	    annotation245=annotation();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, annotation245.getTree());

            	    }
            	    break;

            	default :
            	    if ( cnt84 >= 1 ) break loop84;
            	    if (state.backtracking>0) {state.failed=true; return retval;}
                        EarlyExitException eee =
                            new EarlyExitException(84, input);
                        throw eee;
                }
                cnt84++;
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 44, annotations_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "annotations"


    public static class annotation_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "annotation"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:802:1: annotation : '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )? ->;
    public final JavaTreeParser.annotation_return annotation() throws RecognitionException {
        JavaTreeParser.annotation_return retval = new JavaTreeParser.annotation_return();
        retval.start = input.LT(1);

        int annotation_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal246=null;
        Token char_literal248=null;
        Token char_literal251=null;
        JavaTreeParser.qualifiedName_return qualifiedName247 =null;

        JavaTreeParser.elementValuePairs_return elementValuePairs249 =null;

        JavaTreeParser.elementValue_return elementValue250 =null;


        Object char_literal246_tree=null;
        Object char_literal248_tree=null;
        Object char_literal251_tree=null;
        RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
        RewriteRuleTokenStream stream_MONKEYS_AT=new RewriteRuleTokenStream(adaptor,"token MONKEYS_AT");
        RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
        RewriteRuleSubtreeStream stream_elementValue=new RewriteRuleSubtreeStream(adaptor,"rule elementValue");
        RewriteRuleSubtreeStream stream_qualifiedName=new RewriteRuleSubtreeStream(adaptor,"rule qualifiedName");
        RewriteRuleSubtreeStream stream_elementValuePairs=new RewriteRuleSubtreeStream(adaptor,"rule elementValuePairs");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 45) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:803:5: ( '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )? ->)
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:803:9: '@' qualifiedName ( '(' ( elementValuePairs | elementValue )? ')' )?
            {
            char_literal246=(Token)match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotation4859); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_MONKEYS_AT.add(char_literal246);


            pushFollow(FOLLOW_qualifiedName_in_annotation4861);
            qualifiedName247=qualifiedName();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_qualifiedName.add(qualifiedName247.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:804:9: ( '(' ( elementValuePairs | elementValue )? ')' )?
            int alt86=2;
            int LA86_0 = input.LA(1);

            if ( (LA86_0==LPAREN) ) {
                alt86=1;
            }
            switch (alt86) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:804:13: '(' ( elementValuePairs | elementValue )? ')'
                    {
                    char_literal248=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_annotation4875); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_LPAREN.add(char_literal248);


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:805:19: ( elementValuePairs | elementValue )?
                    int alt85=3;
                    int LA85_0 = input.LA(1);

                    if ( (LA85_0==IDENTIFIER) ) {
                        int LA85_1 = input.LA(2);

                        if ( (LA85_1==EQ) ) {
                            alt85=1;
                        }
                        else if ( ((LA85_1 >= AMP && LA85_1 <= AMPAMP)||(LA85_1 >= BANGEQ && LA85_1 <= BARBAR)||LA85_1==CARET||LA85_1==DOT||LA85_1==EQEQ||LA85_1==GT||LA85_1==INSTANCEOF||LA85_1==LBRACKET||(LA85_1 >= LPAREN && LA85_1 <= LT)||LA85_1==PERCENT||LA85_1==PLUS||LA85_1==PLUSPLUS||LA85_1==QUES||LA85_1==RPAREN||LA85_1==SLASH||LA85_1==STAR||LA85_1==SUB||LA85_1==SUBSUB) ) {
                            alt85=2;
                        }
                    }
                    else if ( (LA85_0==BANG||LA85_0==BOOLEAN||LA85_0==BYTE||(LA85_0 >= CHAR && LA85_0 <= CHARLITERAL)||(LA85_0 >= DOUBLE && LA85_0 <= DOUBLELITERAL)||LA85_0==FALSE||(LA85_0 >= FLOAT && LA85_0 <= FLOATLITERAL)||LA85_0==INT||LA85_0==INTLITERAL||LA85_0==LBRACE||(LA85_0 >= LONG && LA85_0 <= LPAREN)||LA85_0==MONKEYS_AT||LA85_0==NEW||LA85_0==NULL||LA85_0==PLUS||LA85_0==PLUSPLUS||LA85_0==SHORT||(LA85_0 >= STRINGLITERAL && LA85_0 <= SUB)||(LA85_0 >= SUBSUB && LA85_0 <= SUPER)||LA85_0==THIS||LA85_0==TILDE||LA85_0==TRUE||LA85_0==VOID) ) {
                        alt85=2;
                    }
                    switch (alt85) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:805:23: elementValuePairs
                            {
                            pushFollow(FOLLOW_elementValuePairs_in_annotation4902);
                            elementValuePairs249=elementValuePairs();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_elementValuePairs.add(elementValuePairs249.getTree());

                            }
                            break;
                        case 2 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:806:23: elementValue
                            {
                            pushFollow(FOLLOW_elementValue_in_annotation4926);
                            elementValue250=elementValue();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) stream_elementValue.add(elementValue250.getTree());

                            }
                            break;

                    }


                    char_literal251=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_annotation4962); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_RPAREN.add(char_literal251);


                    }
                    break;

            }


            // AST REWRITE
            // elements: 
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 810:9: ->
            {
                root_0 = null;
            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 45, annotation_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "annotation"


    public static class elementValuePairs_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "elementValuePairs"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:813:1: elementValuePairs : elementValuePair ( ',' elementValuePair )* ;
    public final JavaTreeParser.elementValuePairs_return elementValuePairs() throws RecognitionException {
        JavaTreeParser.elementValuePairs_return retval = new JavaTreeParser.elementValuePairs_return();
        retval.start = input.LT(1);

        int elementValuePairs_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal253=null;
        JavaTreeParser.elementValuePair_return elementValuePair252 =null;

        JavaTreeParser.elementValuePair_return elementValuePair254 =null;


        Object char_literal253_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 46) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:814:5: ( elementValuePair ( ',' elementValuePair )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:814:9: elementValuePair ( ',' elementValuePair )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_elementValuePair_in_elementValuePairs5005);
            elementValuePair252=elementValuePair();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, elementValuePair252.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:815:9: ( ',' elementValuePair )*
            loop87:
            do {
                int alt87=2;
                int LA87_0 = input.LA(1);

                if ( (LA87_0==COMMA) ) {
                    alt87=1;
                }


                switch (alt87) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:815:10: ',' elementValuePair
            	    {
            	    char_literal253=(Token)match(input,COMMA,FOLLOW_COMMA_in_elementValuePairs5016); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal253_tree = 
            	    (Object)adaptor.create(char_literal253)
            	    ;
            	    adaptor.addChild(root_0, char_literal253_tree);
            	    }

            	    pushFollow(FOLLOW_elementValuePair_in_elementValuePairs5018);
            	    elementValuePair254=elementValuePair();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, elementValuePair254.getTree());

            	    }
            	    break;

            	default :
            	    break loop87;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 46, elementValuePairs_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "elementValuePairs"


    public static class elementValuePair_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "elementValuePair"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:819:1: elementValuePair : IDENTIFIER '=' elementValue ;
    public final JavaTreeParser.elementValuePair_return elementValuePair() throws RecognitionException {
        JavaTreeParser.elementValuePair_return retval = new JavaTreeParser.elementValuePair_return();
        retval.start = input.LT(1);

        int elementValuePair_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER255=null;
        Token char_literal256=null;
        JavaTreeParser.elementValue_return elementValue257 =null;


        Object IDENTIFIER255_tree=null;
        Object char_literal256_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 47) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:820:5: ( IDENTIFIER '=' elementValue )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:820:9: IDENTIFIER '=' elementValue
            {
            root_0 = (Object)adaptor.nil();


            IDENTIFIER255=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_elementValuePair5049); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER255_tree = 
            (Object)adaptor.create(IDENTIFIER255)
            ;
            adaptor.addChild(root_0, IDENTIFIER255_tree);
            }

            char_literal256=(Token)match(input,EQ,FOLLOW_EQ_in_elementValuePair5051); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal256_tree = 
            (Object)adaptor.create(char_literal256)
            ;
            adaptor.addChild(root_0, char_literal256_tree);
            }

            pushFollow(FOLLOW_elementValue_in_elementValuePair5053);
            elementValue257=elementValue();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, elementValue257.getTree());

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 47, elementValuePair_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "elementValuePair"


    public static class elementValue_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "elementValue"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:823:1: elementValue : ( conditionalExpression | annotation | elementValueArrayInitializer );
    public final JavaTreeParser.elementValue_return elementValue() throws RecognitionException {
        JavaTreeParser.elementValue_return retval = new JavaTreeParser.elementValue_return();
        retval.start = input.LT(1);

        int elementValue_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.conditionalExpression_return conditionalExpression258 =null;

        JavaTreeParser.annotation_return annotation259 =null;

        JavaTreeParser.elementValueArrayInitializer_return elementValueArrayInitializer260 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 48) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:824:5: ( conditionalExpression | annotation | elementValueArrayInitializer )
            int alt88=3;
            switch ( input.LA(1) ) {
            case BANG:
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CHARLITERAL:
            case DOUBLE:
            case DOUBLELITERAL:
            case FALSE:
            case FLOAT:
            case FLOATLITERAL:
            case IDENTIFIER:
            case INT:
            case INTLITERAL:
            case LONG:
            case LONGLITERAL:
            case LPAREN:
            case NEW:
            case NULL:
            case PLUS:
            case PLUSPLUS:
            case SHORT:
            case STRINGLITERAL:
            case SUB:
            case SUBSUB:
            case SUPER:
            case THIS:
            case TILDE:
            case TRUE:
            case VOID:
                {
                alt88=1;
                }
                break;
            case MONKEYS_AT:
                {
                alt88=2;
                }
                break;
            case LBRACE:
                {
                alt88=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 88, 0, input);

                throw nvae;

            }

            switch (alt88) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:824:9: conditionalExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_conditionalExpression_in_elementValue5073);
                    conditionalExpression258=conditionalExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalExpression258.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:825:9: annotation
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_annotation_in_elementValue5083);
                    annotation259=annotation();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, annotation259.getTree());

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:826:9: elementValueArrayInitializer
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_elementValueArrayInitializer_in_elementValue5093);
                    elementValueArrayInitializer260=elementValueArrayInitializer();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, elementValueArrayInitializer260.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 48, elementValue_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "elementValue"


    public static class elementValueArrayInitializer_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "elementValueArrayInitializer"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:829:1: elementValueArrayInitializer : '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}' ;
    public final JavaTreeParser.elementValueArrayInitializer_return elementValueArrayInitializer() throws RecognitionException {
        JavaTreeParser.elementValueArrayInitializer_return retval = new JavaTreeParser.elementValueArrayInitializer_return();
        retval.start = input.LT(1);

        int elementValueArrayInitializer_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal261=null;
        Token char_literal263=null;
        Token char_literal265=null;
        Token char_literal266=null;
        JavaTreeParser.elementValue_return elementValue262 =null;

        JavaTreeParser.elementValue_return elementValue264 =null;


        Object char_literal261_tree=null;
        Object char_literal263_tree=null;
        Object char_literal265_tree=null;
        Object char_literal266_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 49) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:830:5: ( '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:830:9: '{' ( elementValue ( ',' elementValue )* )? ( ',' )? '}'
            {
            root_0 = (Object)adaptor.nil();


            char_literal261=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_elementValueArrayInitializer5113); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal261_tree = 
            (Object)adaptor.create(char_literal261)
            ;
            adaptor.addChild(root_0, char_literal261_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:831:9: ( elementValue ( ',' elementValue )* )?
            int alt90=2;
            int LA90_0 = input.LA(1);

            if ( (LA90_0==BANG||LA90_0==BOOLEAN||LA90_0==BYTE||(LA90_0 >= CHAR && LA90_0 <= CHARLITERAL)||(LA90_0 >= DOUBLE && LA90_0 <= DOUBLELITERAL)||LA90_0==FALSE||(LA90_0 >= FLOAT && LA90_0 <= FLOATLITERAL)||LA90_0==IDENTIFIER||LA90_0==INT||LA90_0==INTLITERAL||LA90_0==LBRACE||(LA90_0 >= LONG && LA90_0 <= LPAREN)||LA90_0==MONKEYS_AT||LA90_0==NEW||LA90_0==NULL||LA90_0==PLUS||LA90_0==PLUSPLUS||LA90_0==SHORT||(LA90_0 >= STRINGLITERAL && LA90_0 <= SUB)||(LA90_0 >= SUBSUB && LA90_0 <= SUPER)||LA90_0==THIS||LA90_0==TILDE||LA90_0==TRUE||LA90_0==VOID) ) {
                alt90=1;
            }
            switch (alt90) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:831:10: elementValue ( ',' elementValue )*
                    {
                    pushFollow(FOLLOW_elementValue_in_elementValueArrayInitializer5124);
                    elementValue262=elementValue();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, elementValue262.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:832:13: ( ',' elementValue )*
                    loop89:
                    do {
                        int alt89=2;
                        int LA89_0 = input.LA(1);

                        if ( (LA89_0==COMMA) ) {
                            int LA89_1 = input.LA(2);

                            if ( (LA89_1==BANG||LA89_1==BOOLEAN||LA89_1==BYTE||(LA89_1 >= CHAR && LA89_1 <= CHARLITERAL)||(LA89_1 >= DOUBLE && LA89_1 <= DOUBLELITERAL)||LA89_1==FALSE||(LA89_1 >= FLOAT && LA89_1 <= FLOATLITERAL)||LA89_1==IDENTIFIER||LA89_1==INT||LA89_1==INTLITERAL||LA89_1==LBRACE||(LA89_1 >= LONG && LA89_1 <= LPAREN)||LA89_1==MONKEYS_AT||LA89_1==NEW||LA89_1==NULL||LA89_1==PLUS||LA89_1==PLUSPLUS||LA89_1==SHORT||(LA89_1 >= STRINGLITERAL && LA89_1 <= SUB)||(LA89_1 >= SUBSUB && LA89_1 <= SUPER)||LA89_1==THIS||LA89_1==TILDE||LA89_1==TRUE||LA89_1==VOID) ) {
                                alt89=1;
                            }


                        }


                        switch (alt89) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:832:14: ',' elementValue
                    	    {
                    	    char_literal263=(Token)match(input,COMMA,FOLLOW_COMMA_in_elementValueArrayInitializer5139); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal263_tree = 
                    	    (Object)adaptor.create(char_literal263)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal263_tree);
                    	    }

                    	    pushFollow(FOLLOW_elementValue_in_elementValueArrayInitializer5141);
                    	    elementValue264=elementValue();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, elementValue264.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop89;
                        }
                    } while (true);


                    }
                    break;

            }


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:834:12: ( ',' )?
            int alt91=2;
            int LA91_0 = input.LA(1);

            if ( (LA91_0==COMMA) ) {
                alt91=1;
            }
            switch (alt91) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:834:13: ','
                    {
                    char_literal265=(Token)match(input,COMMA,FOLLOW_COMMA_in_elementValueArrayInitializer5170); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal265_tree = 
                    (Object)adaptor.create(char_literal265)
                    ;
                    adaptor.addChild(root_0, char_literal265_tree);
                    }

                    }
                    break;

            }


            char_literal266=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_elementValueArrayInitializer5174); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal266_tree = 
            (Object)adaptor.create(char_literal266)
            ;
            adaptor.addChild(root_0, char_literal266_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 49, elementValueArrayInitializer_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "elementValueArrayInitializer"


    public static class annotationTypeDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "annotationTypeDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:841:1: annotationTypeDeclaration : modifiers '@' 'interface' IDENTIFIER annotationTypeBody -> ^( ANNOTATION ( ^( MODIFIER modifiers ) )* ^( NAME IDENTIFIER ) ( annotationTypeBody )* ) ;
    public final JavaTreeParser.annotationTypeDeclaration_return annotationTypeDeclaration() throws RecognitionException {
        JavaTreeParser.annotationTypeDeclaration_return retval = new JavaTreeParser.annotationTypeDeclaration_return();
        retval.start = input.LT(1);

        int annotationTypeDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal268=null;
        Token string_literal269=null;
        Token IDENTIFIER270=null;
        JavaTreeParser.modifiers_return modifiers267 =null;

        JavaTreeParser.annotationTypeBody_return annotationTypeBody271 =null;


        Object char_literal268_tree=null;
        Object string_literal269_tree=null;
        Object IDENTIFIER270_tree=null;
        RewriteRuleTokenStream stream_MONKEYS_AT=new RewriteRuleTokenStream(adaptor,"token MONKEYS_AT");
        RewriteRuleTokenStream stream_INTERFACE=new RewriteRuleTokenStream(adaptor,"token INTERFACE");
        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
        RewriteRuleSubtreeStream stream_annotationTypeBody=new RewriteRuleSubtreeStream(adaptor,"rule annotationTypeBody");
        RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 50) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:842:5: ( modifiers '@' 'interface' IDENTIFIER annotationTypeBody -> ^( ANNOTATION ( ^( MODIFIER modifiers ) )* ^( NAME IDENTIFIER ) ( annotationTypeBody )* ) )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:842:9: modifiers '@' 'interface' IDENTIFIER annotationTypeBody
            {
            pushFollow(FOLLOW_modifiers_in_annotationTypeDeclaration5197);
            modifiers267=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_modifiers.add(modifiers267.getTree());

            char_literal268=(Token)match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotationTypeDeclaration5199); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_MONKEYS_AT.add(char_literal268);


            string_literal269=(Token)match(input,INTERFACE,FOLLOW_INTERFACE_in_annotationTypeDeclaration5209); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_INTERFACE.add(string_literal269);


            IDENTIFIER270=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationTypeDeclaration5219); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER270);


            pushFollow(FOLLOW_annotationTypeBody_in_annotationTypeDeclaration5229);
            annotationTypeBody271=annotationTypeBody();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_annotationTypeBody.add(annotationTypeBody271.getTree());

            // AST REWRITE
            // elements: modifiers, IDENTIFIER, annotationTypeBody
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 846:9: -> ^( ANNOTATION ( ^( MODIFIER modifiers ) )* ^( NAME IDENTIFIER ) ( annotationTypeBody )* )
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:847:9: ^( ANNOTATION ( ^( MODIFIER modifiers ) )* ^( NAME IDENTIFIER ) ( annotationTypeBody )* )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(ANNOTATION, "ANNOTATION")
                , root_1);

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:847:22: ( ^( MODIFIER modifiers ) )*
                while ( stream_modifiers.hasNext() ) {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:847:22: ^( MODIFIER modifiers )
                    {
                    Object root_2 = (Object)adaptor.nil();
                    root_2 = (Object)adaptor.becomeRoot(
                    (Object)adaptor.create(MODIFIER, "MODIFIER")
                    , root_2);

                    adaptor.addChild(root_2, stream_modifiers.nextTree());

                    adaptor.addChild(root_1, root_2);
                    }

                }
                stream_modifiers.reset();

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:847:45: ^( NAME IDENTIFIER )
                {
                Object root_2 = (Object)adaptor.nil();
                root_2 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(NAME, "NAME")
                , root_2);

                adaptor.addChild(root_2, 
                stream_IDENTIFIER.nextNode()
                );

                adaptor.addChild(root_1, root_2);
                }

                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:847:64: ( annotationTypeBody )*
                while ( stream_annotationTypeBody.hasNext() ) {
                    adaptor.addChild(root_1, stream_annotationTypeBody.nextTree());

                }
                stream_annotationTypeBody.reset();

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 50, annotationTypeDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "annotationTypeDeclaration"


    public static class annotationTypeBody_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "annotationTypeBody"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:851:1: annotationTypeBody : '{' ( annotationTypeElementDeclaration )* '}' -> ( annotationTypeElementDeclaration )* ;
    public final JavaTreeParser.annotationTypeBody_return annotationTypeBody() throws RecognitionException {
        JavaTreeParser.annotationTypeBody_return retval = new JavaTreeParser.annotationTypeBody_return();
        retval.start = input.LT(1);

        int annotationTypeBody_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal272=null;
        Token char_literal274=null;
        JavaTreeParser.annotationTypeElementDeclaration_return annotationTypeElementDeclaration273 =null;


        Object char_literal272_tree=null;
        Object char_literal274_tree=null;
        RewriteRuleTokenStream stream_RBRACE=new RewriteRuleTokenStream(adaptor,"token RBRACE");
        RewriteRuleTokenStream stream_LBRACE=new RewriteRuleTokenStream(adaptor,"token LBRACE");
        RewriteRuleSubtreeStream stream_annotationTypeElementDeclaration=new RewriteRuleSubtreeStream(adaptor,"rule annotationTypeElementDeclaration");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 51) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:852:5: ( '{' ( annotationTypeElementDeclaration )* '}' -> ( annotationTypeElementDeclaration )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:852:9: '{' ( annotationTypeElementDeclaration )* '}'
            {
            char_literal272=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_annotationTypeBody5288); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_LBRACE.add(char_literal272);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:853:9: ( annotationTypeElementDeclaration )*
            loop92:
            do {
                int alt92=2;
                int LA92_0 = input.LA(1);

                if ( (LA92_0==ABSTRACT||LA92_0==BOOLEAN||LA92_0==BYTE||LA92_0==CHAR||LA92_0==CLASS||LA92_0==DOUBLE||LA92_0==ENUM||LA92_0==FINAL||LA92_0==FLOAT||LA92_0==IDENTIFIER||(LA92_0 >= INT && LA92_0 <= INTERFACE)||LA92_0==LONG||LA92_0==LT||LA92_0==MONKEYS_AT||LA92_0==NATIVE||(LA92_0 >= PRIVATE && LA92_0 <= PUBLIC)||(LA92_0 >= SEMI && LA92_0 <= SHORT)||(LA92_0 >= STATIC && LA92_0 <= STRICTFP)||LA92_0==SYNCHRONIZED||LA92_0==TRANSIENT||(LA92_0 >= VOID && LA92_0 <= VOLATILE)) ) {
                    alt92=1;
                }


                switch (alt92) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:853:10: annotationTypeElementDeclaration
            	    {
            	    pushFollow(FOLLOW_annotationTypeElementDeclaration_in_annotationTypeBody5300);
            	    annotationTypeElementDeclaration273=annotationTypeElementDeclaration();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) stream_annotationTypeElementDeclaration.add(annotationTypeElementDeclaration273.getTree());

            	    }
            	    break;

            	default :
            	    break loop92;
                }
            } while (true);


            char_literal274=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_annotationTypeBody5322); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_RBRACE.add(char_literal274);


            // AST REWRITE
            // elements: annotationTypeElementDeclaration
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 856:9: -> ( annotationTypeElementDeclaration )*
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:857:9: ( annotationTypeElementDeclaration )*
                while ( stream_annotationTypeElementDeclaration.hasNext() ) {
                    adaptor.addChild(root_0, stream_annotationTypeElementDeclaration.nextTree());

                }
                stream_annotationTypeElementDeclaration.reset();

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 51, annotationTypeBody_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "annotationTypeBody"


    public static class annotationTypeElementDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "annotationTypeElementDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:863:1: annotationTypeElementDeclaration : ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' );
    public final JavaTreeParser.annotationTypeElementDeclaration_return annotationTypeElementDeclaration() throws RecognitionException {
        JavaTreeParser.annotationTypeElementDeclaration_return retval = new JavaTreeParser.annotationTypeElementDeclaration_return();
        retval.start = input.LT(1);

        int annotationTypeElementDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal281=null;
        JavaTreeParser.annotationMethodDeclaration_return annotationMethodDeclaration275 =null;

        JavaTreeParser.interfaceFieldDeclaration_return interfaceFieldDeclaration276 =null;

        JavaTreeParser.normalClassDeclaration_return normalClassDeclaration277 =null;

        JavaTreeParser.normalInterfaceDeclaration_return normalInterfaceDeclaration278 =null;

        JavaTreeParser.enumDeclaration_return enumDeclaration279 =null;

        JavaTreeParser.annotationTypeDeclaration_return annotationTypeDeclaration280 =null;


        Object char_literal281_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 52) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:864:5: ( annotationMethodDeclaration | interfaceFieldDeclaration | normalClassDeclaration | normalInterfaceDeclaration | enumDeclaration | annotationTypeDeclaration | ';' )
            int alt93=7;
            switch ( input.LA(1) ) {
            case MONKEYS_AT:
                {
                int LA93_1 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else if ( (synpred128_JavaTree()) ) {
                    alt93=3;
                }
                else if ( (synpred129_JavaTree()) ) {
                    alt93=4;
                }
                else if ( (synpred130_JavaTree()) ) {
                    alt93=5;
                }
                else if ( (synpred131_JavaTree()) ) {
                    alt93=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 1, input);

                    throw nvae;

                }
                }
                break;
            case PUBLIC:
                {
                int LA93_2 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else if ( (synpred128_JavaTree()) ) {
                    alt93=3;
                }
                else if ( (synpred129_JavaTree()) ) {
                    alt93=4;
                }
                else if ( (synpred130_JavaTree()) ) {
                    alt93=5;
                }
                else if ( (synpred131_JavaTree()) ) {
                    alt93=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 2, input);

                    throw nvae;

                }
                }
                break;
            case PROTECTED:
                {
                int LA93_3 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else if ( (synpred128_JavaTree()) ) {
                    alt93=3;
                }
                else if ( (synpred129_JavaTree()) ) {
                    alt93=4;
                }
                else if ( (synpred130_JavaTree()) ) {
                    alt93=5;
                }
                else if ( (synpred131_JavaTree()) ) {
                    alt93=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 3, input);

                    throw nvae;

                }
                }
                break;
            case PRIVATE:
                {
                int LA93_4 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else if ( (synpred128_JavaTree()) ) {
                    alt93=3;
                }
                else if ( (synpred129_JavaTree()) ) {
                    alt93=4;
                }
                else if ( (synpred130_JavaTree()) ) {
                    alt93=5;
                }
                else if ( (synpred131_JavaTree()) ) {
                    alt93=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 4, input);

                    throw nvae;

                }
                }
                break;
            case STATIC:
                {
                int LA93_5 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else if ( (synpred128_JavaTree()) ) {
                    alt93=3;
                }
                else if ( (synpred129_JavaTree()) ) {
                    alt93=4;
                }
                else if ( (synpred130_JavaTree()) ) {
                    alt93=5;
                }
                else if ( (synpred131_JavaTree()) ) {
                    alt93=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 5, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
                {
                int LA93_6 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else if ( (synpred128_JavaTree()) ) {
                    alt93=3;
                }
                else if ( (synpred129_JavaTree()) ) {
                    alt93=4;
                }
                else if ( (synpred130_JavaTree()) ) {
                    alt93=5;
                }
                else if ( (synpred131_JavaTree()) ) {
                    alt93=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 6, input);

                    throw nvae;

                }
                }
                break;
            case FINAL:
                {
                int LA93_7 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else if ( (synpred128_JavaTree()) ) {
                    alt93=3;
                }
                else if ( (synpred129_JavaTree()) ) {
                    alt93=4;
                }
                else if ( (synpred130_JavaTree()) ) {
                    alt93=5;
                }
                else if ( (synpred131_JavaTree()) ) {
                    alt93=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 7, input);

                    throw nvae;

                }
                }
                break;
            case NATIVE:
                {
                int LA93_8 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else if ( (synpred128_JavaTree()) ) {
                    alt93=3;
                }
                else if ( (synpred129_JavaTree()) ) {
                    alt93=4;
                }
                else if ( (synpred130_JavaTree()) ) {
                    alt93=5;
                }
                else if ( (synpred131_JavaTree()) ) {
                    alt93=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 8, input);

                    throw nvae;

                }
                }
                break;
            case SYNCHRONIZED:
                {
                int LA93_9 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else if ( (synpred128_JavaTree()) ) {
                    alt93=3;
                }
                else if ( (synpred129_JavaTree()) ) {
                    alt93=4;
                }
                else if ( (synpred130_JavaTree()) ) {
                    alt93=5;
                }
                else if ( (synpred131_JavaTree()) ) {
                    alt93=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 9, input);

                    throw nvae;

                }
                }
                break;
            case TRANSIENT:
                {
                int LA93_10 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else if ( (synpred128_JavaTree()) ) {
                    alt93=3;
                }
                else if ( (synpred129_JavaTree()) ) {
                    alt93=4;
                }
                else if ( (synpred130_JavaTree()) ) {
                    alt93=5;
                }
                else if ( (synpred131_JavaTree()) ) {
                    alt93=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 10, input);

                    throw nvae;

                }
                }
                break;
            case VOLATILE:
                {
                int LA93_11 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else if ( (synpred128_JavaTree()) ) {
                    alt93=3;
                }
                else if ( (synpred129_JavaTree()) ) {
                    alt93=4;
                }
                else if ( (synpred130_JavaTree()) ) {
                    alt93=5;
                }
                else if ( (synpred131_JavaTree()) ) {
                    alt93=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 11, input);

                    throw nvae;

                }
                }
                break;
            case STRICTFP:
                {
                int LA93_12 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else if ( (synpred128_JavaTree()) ) {
                    alt93=3;
                }
                else if ( (synpred129_JavaTree()) ) {
                    alt93=4;
                }
                else if ( (synpred130_JavaTree()) ) {
                    alt93=5;
                }
                else if ( (synpred131_JavaTree()) ) {
                    alt93=6;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 12, input);

                    throw nvae;

                }
                }
                break;
            case IDENTIFIER:
                {
                int LA93_13 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 13, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case INT:
            case LONG:
            case SHORT:
                {
                int LA93_14 = input.LA(2);

                if ( (synpred126_JavaTree()) ) {
                    alt93=1;
                }
                else if ( (synpred127_JavaTree()) ) {
                    alt93=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 93, 14, input);

                    throw nvae;

                }
                }
                break;
            case CLASS:
                {
                alt93=3;
                }
                break;
            case INTERFACE:
                {
                alt93=4;
                }
                break;
            case ENUM:
                {
                alt93=5;
                }
                break;
            case SEMI:
                {
                alt93=7;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 93, 0, input);

                throw nvae;

            }

            switch (alt93) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:864:9: annotationMethodDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_annotationMethodDeclaration_in_annotationTypeElementDeclaration5366);
                    annotationMethodDeclaration275=annotationMethodDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, annotationMethodDeclaration275.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:865:9: interfaceFieldDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_interfaceFieldDeclaration_in_annotationTypeElementDeclaration5376);
                    interfaceFieldDeclaration276=interfaceFieldDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, interfaceFieldDeclaration276.getTree());

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:866:9: normalClassDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_normalClassDeclaration_in_annotationTypeElementDeclaration5386);
                    normalClassDeclaration277=normalClassDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, normalClassDeclaration277.getTree());

                    }
                    break;
                case 4 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:867:9: normalInterfaceDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_normalInterfaceDeclaration_in_annotationTypeElementDeclaration5396);
                    normalInterfaceDeclaration278=normalInterfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, normalInterfaceDeclaration278.getTree());

                    }
                    break;
                case 5 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:868:9: enumDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_enumDeclaration_in_annotationTypeElementDeclaration5406);
                    enumDeclaration279=enumDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, enumDeclaration279.getTree());

                    }
                    break;
                case 6 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:869:9: annotationTypeDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_annotationTypeDeclaration_in_annotationTypeElementDeclaration5416);
                    annotationTypeDeclaration280=annotationTypeDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, annotationTypeDeclaration280.getTree());

                    }
                    break;
                case 7 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:870:9: ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal281=(Token)match(input,SEMI,FOLLOW_SEMI_in_annotationTypeElementDeclaration5426); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal281_tree = 
                    (Object)adaptor.create(char_literal281)
                    ;
                    adaptor.addChild(root_0, char_literal281_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 52, annotationTypeElementDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "annotationTypeElementDeclaration"


    public static class annotationMethodDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "annotationMethodDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:873:1: annotationMethodDeclaration : modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';' -> ^( ANNOTATION_METHOD type IDENTIFIER ) ;
    public final JavaTreeParser.annotationMethodDeclaration_return annotationMethodDeclaration() throws RecognitionException {
        JavaTreeParser.annotationMethodDeclaration_return retval = new JavaTreeParser.annotationMethodDeclaration_return();
        retval.start = input.LT(1);

        int annotationMethodDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER284=null;
        Token char_literal285=null;
        Token char_literal286=null;
        Token string_literal287=null;
        Token char_literal289=null;
        JavaTreeParser.modifiers_return modifiers282 =null;

        JavaTreeParser.type_return type283 =null;

        JavaTreeParser.elementValue_return elementValue288 =null;


        Object IDENTIFIER284_tree=null;
        Object char_literal285_tree=null;
        Object char_literal286_tree=null;
        Object string_literal287_tree=null;
        Object char_literal289_tree=null;
        RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
        RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
        RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
        RewriteRuleTokenStream stream_DEFAULT=new RewriteRuleTokenStream(adaptor,"token DEFAULT");
        RewriteRuleSubtreeStream stream_elementValue=new RewriteRuleSubtreeStream(adaptor,"rule elementValue");
        RewriteRuleSubtreeStream stream_modifiers=new RewriteRuleSubtreeStream(adaptor,"rule modifiers");
        RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 53) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:874:5: ( modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';' -> ^( ANNOTATION_METHOD type IDENTIFIER ) )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:874:9: modifiers type IDENTIFIER '(' ')' ( 'default' elementValue )? ';'
            {
            pushFollow(FOLLOW_modifiers_in_annotationMethodDeclaration5446);
            modifiers282=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_modifiers.add(modifiers282.getTree());

            pushFollow(FOLLOW_type_in_annotationMethodDeclaration5448);
            type283=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) stream_type.add(type283.getTree());

            IDENTIFIER284=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationMethodDeclaration5450); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_IDENTIFIER.add(IDENTIFIER284);


            char_literal285=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_annotationMethodDeclaration5460); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_LPAREN.add(char_literal285);


            char_literal286=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_annotationMethodDeclaration5462); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_RPAREN.add(char_literal286);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:875:17: ( 'default' elementValue )?
            int alt94=2;
            int LA94_0 = input.LA(1);

            if ( (LA94_0==DEFAULT) ) {
                alt94=1;
            }
            switch (alt94) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:875:18: 'default' elementValue
                    {
                    string_literal287=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_annotationMethodDeclaration5465); if (state.failed) return retval; 
                    if ( state.backtracking==0 ) stream_DEFAULT.add(string_literal287);


                    pushFollow(FOLLOW_elementValue_in_annotationMethodDeclaration5467);
                    elementValue288=elementValue();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) stream_elementValue.add(elementValue288.getTree());

                    }
                    break;

            }


            char_literal289=(Token)match(input,SEMI,FOLLOW_SEMI_in_annotationMethodDeclaration5496); if (state.failed) return retval; 
            if ( state.backtracking==0 ) stream_SEMI.add(char_literal289);


            // AST REWRITE
            // elements: type, IDENTIFIER
            // token labels: 
            // rule labels: retval
            // token list labels: 
            // rule list labels: 
            // wildcard labels: 
            if ( state.backtracking==0 ) {

            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);

            root_0 = (Object)adaptor.nil();
            // 878:9: -> ^( ANNOTATION_METHOD type IDENTIFIER )
            {
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:878:12: ^( ANNOTATION_METHOD type IDENTIFIER )
                {
                Object root_1 = (Object)adaptor.nil();
                root_1 = (Object)adaptor.becomeRoot(
                (Object)adaptor.create(ANNOTATION_METHOD, "ANNOTATION_METHOD")
                , root_1);

                adaptor.addChild(root_1, stream_type.nextTree());

                adaptor.addChild(root_1, 
                stream_IDENTIFIER.nextNode()
                );

                adaptor.addChild(root_0, root_1);
                }

            }


            retval.tree = root_0;
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 53, annotationMethodDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "annotationMethodDeclaration"


    public static class block_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "block"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:881:1: block : '{' ( blockStatement )* '}' ;
    public final JavaTreeParser.block_return block() throws RecognitionException {
        JavaTreeParser.block_return retval = new JavaTreeParser.block_return();
        retval.start = input.LT(1);

        int block_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal290=null;
        Token char_literal292=null;
        JavaTreeParser.blockStatement_return blockStatement291 =null;


        Object char_literal290_tree=null;
        Object char_literal292_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 54) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:882:5: ( '{' ( blockStatement )* '}' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:882:9: '{' ( blockStatement )* '}'
            {
            root_0 = (Object)adaptor.nil();


            char_literal290=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_block5538); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal290_tree = 
            (Object)adaptor.create(char_literal290)
            ;
            adaptor.addChild(root_0, char_literal290_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:883:9: ( blockStatement )*
            loop95:
            do {
                int alt95=2;
                int LA95_0 = input.LA(1);

                if ( (LA95_0==ABSTRACT||(LA95_0 >= ASSERT && LA95_0 <= BANG)||(LA95_0 >= BOOLEAN && LA95_0 <= BYTE)||(LA95_0 >= CHAR && LA95_0 <= CLASS)||LA95_0==CONTINUE||LA95_0==DO||(LA95_0 >= DOUBLE && LA95_0 <= DOUBLELITERAL)||LA95_0==ENUM||LA95_0==FALSE||LA95_0==FINAL||(LA95_0 >= FLOAT && LA95_0 <= FOR)||(LA95_0 >= IDENTIFIER && LA95_0 <= IF)||(LA95_0 >= INT && LA95_0 <= INTLITERAL)||LA95_0==LBRACE||(LA95_0 >= LONG && LA95_0 <= LT)||LA95_0==MONKEYS_AT||(LA95_0 >= NATIVE && LA95_0 <= NEW)||LA95_0==NULL||LA95_0==PLUS||(LA95_0 >= PLUSPLUS && LA95_0 <= PUBLIC)||LA95_0==RETURN||(LA95_0 >= SEMI && LA95_0 <= SHORT)||(LA95_0 >= STATIC && LA95_0 <= SUB)||(LA95_0 >= SUBSUB && LA95_0 <= SYNCHRONIZED)||(LA95_0 >= THIS && LA95_0 <= THROW)||(LA95_0 >= TILDE && LA95_0 <= TRY)||(LA95_0 >= VOID && LA95_0 <= WHILE)) ) {
                    alt95=1;
                }


                switch (alt95) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:883:10: blockStatement
            	    {
            	    pushFollow(FOLLOW_blockStatement_in_block5549);
            	    blockStatement291=blockStatement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, blockStatement291.getTree());

            	    }
            	    break;

            	default :
            	    break loop95;
                }
            } while (true);


            char_literal292=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_block5570); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal292_tree = 
            (Object)adaptor.create(char_literal292)
            ;
            adaptor.addChild(root_0, char_literal292_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 54, block_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "block"


    public static class blockStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "blockStatement"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:912:1: blockStatement : ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement );
    public final JavaTreeParser.blockStatement_return blockStatement() throws RecognitionException {
        JavaTreeParser.blockStatement_return retval = new JavaTreeParser.blockStatement_return();
        retval.start = input.LT(1);

        int blockStatement_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.localVariableDeclarationStatement_return localVariableDeclarationStatement293 =null;

        JavaTreeParser.classOrInterfaceDeclaration_return classOrInterfaceDeclaration294 =null;

        JavaTreeParser.statement_return statement295 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 55) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:913:5: ( localVariableDeclarationStatement | classOrInterfaceDeclaration | statement )
            int alt96=3;
            switch ( input.LA(1) ) {
            case FINAL:
                {
                int LA96_1 = input.LA(2);

                if ( (synpred134_JavaTree()) ) {
                    alt96=1;
                }
                else if ( (synpred135_JavaTree()) ) {
                    alt96=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 1, input);

                    throw nvae;

                }
                }
                break;
            case MONKEYS_AT:
                {
                int LA96_2 = input.LA(2);

                if ( (synpred134_JavaTree()) ) {
                    alt96=1;
                }
                else if ( (synpred135_JavaTree()) ) {
                    alt96=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 2, input);

                    throw nvae;

                }
                }
                break;
            case IDENTIFIER:
                {
                int LA96_3 = input.LA(2);

                if ( (synpred134_JavaTree()) ) {
                    alt96=1;
                }
                else if ( (true) ) {
                    alt96=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 3, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case INT:
            case LONG:
            case SHORT:
                {
                int LA96_4 = input.LA(2);

                if ( (synpred134_JavaTree()) ) {
                    alt96=1;
                }
                else if ( (true) ) {
                    alt96=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 4, input);

                    throw nvae;

                }
                }
                break;
            case ABSTRACT:
            case CLASS:
            case ENUM:
            case INTERFACE:
            case NATIVE:
            case PRIVATE:
            case PROTECTED:
            case PUBLIC:
            case STATIC:
            case STRICTFP:
            case TRANSIENT:
            case VOLATILE:
                {
                alt96=2;
                }
                break;
            case SYNCHRONIZED:
                {
                int LA96_11 = input.LA(2);

                if ( (synpred135_JavaTree()) ) {
                    alt96=2;
                }
                else if ( (true) ) {
                    alt96=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 96, 11, input);

                    throw nvae;

                }
                }
                break;
            case ASSERT:
            case BANG:
            case BREAK:
            case CHARLITERAL:
            case CONTINUE:
            case DO:
            case DOUBLELITERAL:
            case FALSE:
            case FLOATLITERAL:
            case FOR:
            case IF:
            case INTLITERAL:
            case LBRACE:
            case LONGLITERAL:
            case LPAREN:
            case NEW:
            case NULL:
            case PLUS:
            case PLUSPLUS:
            case RETURN:
            case SEMI:
            case STRINGLITERAL:
            case SUB:
            case SUBSUB:
            case SUPER:
            case SWITCH:
            case THIS:
            case THROW:
            case TILDE:
            case TRUE:
            case TRY:
            case VOID:
            case WHILE:
                {
                alt96=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 96, 0, input);

                throw nvae;

            }

            switch (alt96) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:913:9: localVariableDeclarationStatement
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_localVariableDeclarationStatement_in_blockStatement5592);
                    localVariableDeclarationStatement293=localVariableDeclarationStatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, localVariableDeclarationStatement293.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:914:9: classOrInterfaceDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_classOrInterfaceDeclaration_in_blockStatement5602);
                    classOrInterfaceDeclaration294=classOrInterfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, classOrInterfaceDeclaration294.getTree());

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:915:9: statement
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_statement_in_blockStatement5612);
                    statement295=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement295.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 55, blockStatement_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "blockStatement"


    public static class localVariableDeclarationStatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "localVariableDeclarationStatement"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:919:1: localVariableDeclarationStatement : localVariableDeclaration ';' ;
    public final JavaTreeParser.localVariableDeclarationStatement_return localVariableDeclarationStatement() throws RecognitionException {
        JavaTreeParser.localVariableDeclarationStatement_return retval = new JavaTreeParser.localVariableDeclarationStatement_return();
        retval.start = input.LT(1);

        int localVariableDeclarationStatement_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal297=null;
        JavaTreeParser.localVariableDeclaration_return localVariableDeclaration296 =null;


        Object char_literal297_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 56) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:920:5: ( localVariableDeclaration ';' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:920:9: localVariableDeclaration ';'
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_localVariableDeclaration_in_localVariableDeclarationStatement5633);
            localVariableDeclaration296=localVariableDeclaration();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, localVariableDeclaration296.getTree());

            char_literal297=(Token)match(input,SEMI,FOLLOW_SEMI_in_localVariableDeclarationStatement5643); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal297_tree = 
            (Object)adaptor.create(char_literal297)
            ;
            adaptor.addChild(root_0, char_literal297_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 56, localVariableDeclarationStatement_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "localVariableDeclarationStatement"


    public static class localVariableDeclaration_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "localVariableDeclaration"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:924:1: localVariableDeclaration : variableModifiers type variableDeclarator ( ',' variableDeclarator )* ;
    public final JavaTreeParser.localVariableDeclaration_return localVariableDeclaration() throws RecognitionException {
        JavaTreeParser.localVariableDeclaration_return retval = new JavaTreeParser.localVariableDeclaration_return();
        retval.start = input.LT(1);

        int localVariableDeclaration_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal301=null;
        JavaTreeParser.variableModifiers_return variableModifiers298 =null;

        JavaTreeParser.type_return type299 =null;

        JavaTreeParser.variableDeclarator_return variableDeclarator300 =null;

        JavaTreeParser.variableDeclarator_return variableDeclarator302 =null;


        Object char_literal301_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 57) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:925:5: ( variableModifiers type variableDeclarator ( ',' variableDeclarator )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:925:9: variableModifiers type variableDeclarator ( ',' variableDeclarator )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_variableModifiers_in_localVariableDeclaration5663);
            variableModifiers298=variableModifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, variableModifiers298.getTree());

            pushFollow(FOLLOW_type_in_localVariableDeclaration5665);
            type299=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, type299.getTree());

            pushFollow(FOLLOW_variableDeclarator_in_localVariableDeclaration5675);
            variableDeclarator300=variableDeclarator();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, variableDeclarator300.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:927:9: ( ',' variableDeclarator )*
            loop97:
            do {
                int alt97=2;
                int LA97_0 = input.LA(1);

                if ( (LA97_0==COMMA) ) {
                    alt97=1;
                }


                switch (alt97) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:927:10: ',' variableDeclarator
            	    {
            	    char_literal301=(Token)match(input,COMMA,FOLLOW_COMMA_in_localVariableDeclaration5686); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal301_tree = 
            	    (Object)adaptor.create(char_literal301)
            	    ;
            	    adaptor.addChild(root_0, char_literal301_tree);
            	    }

            	    pushFollow(FOLLOW_variableDeclarator_in_localVariableDeclaration5688);
            	    variableDeclarator302=variableDeclarator();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, variableDeclarator302.getTree());

            	    }
            	    break;

            	default :
            	    break loop97;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 57, localVariableDeclaration_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "localVariableDeclaration"


    public static class statement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "statement"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:931:1: statement : ( block | ( 'assert' ) expression ( ':' expression )? ';' | 'assert' expression ( ':' expression )? ';' | 'if' parExpression statement ( 'else' statement )? | forstatement | 'while' parExpression statement | 'do' statement 'while' parExpression ';' | trystatement | 'switch' parExpression '{' switchBlockStatementGroups '}' | 'synchronized' parExpression block | 'return' ( expression )? ';' | 'throw' expression ';' | 'break' ( IDENTIFIER )? ';' | 'continue' ( IDENTIFIER )? ';' | expression ';' | IDENTIFIER ':' statement | ';' );
    public final JavaTreeParser.statement_return statement() throws RecognitionException {
        JavaTreeParser.statement_return retval = new JavaTreeParser.statement_return();
        retval.start = input.LT(1);

        int statement_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal304=null;
        Token char_literal306=null;
        Token char_literal308=null;
        Token string_literal309=null;
        Token char_literal311=null;
        Token char_literal313=null;
        Token string_literal314=null;
        Token string_literal317=null;
        Token string_literal320=null;
        Token string_literal323=null;
        Token string_literal325=null;
        Token char_literal327=null;
        Token string_literal329=null;
        Token char_literal331=null;
        Token char_literal333=null;
        Token string_literal334=null;
        Token string_literal337=null;
        Token char_literal339=null;
        Token string_literal340=null;
        Token char_literal342=null;
        Token string_literal343=null;
        Token IDENTIFIER344=null;
        Token char_literal345=null;
        Token string_literal346=null;
        Token IDENTIFIER347=null;
        Token char_literal348=null;
        Token char_literal350=null;
        Token IDENTIFIER351=null;
        Token char_literal352=null;
        Token char_literal354=null;
        JavaTreeParser.block_return block303 =null;

        JavaTreeParser.expression_return expression305 =null;

        JavaTreeParser.expression_return expression307 =null;

        JavaTreeParser.expression_return expression310 =null;

        JavaTreeParser.expression_return expression312 =null;

        JavaTreeParser.parExpression_return parExpression315 =null;

        JavaTreeParser.statement_return statement316 =null;

        JavaTreeParser.statement_return statement318 =null;

        JavaTreeParser.forstatement_return forstatement319 =null;

        JavaTreeParser.parExpression_return parExpression321 =null;

        JavaTreeParser.statement_return statement322 =null;

        JavaTreeParser.statement_return statement324 =null;

        JavaTreeParser.parExpression_return parExpression326 =null;

        JavaTreeParser.trystatement_return trystatement328 =null;

        JavaTreeParser.parExpression_return parExpression330 =null;

        JavaTreeParser.switchBlockStatementGroups_return switchBlockStatementGroups332 =null;

        JavaTreeParser.parExpression_return parExpression335 =null;

        JavaTreeParser.block_return block336 =null;

        JavaTreeParser.expression_return expression338 =null;

        JavaTreeParser.expression_return expression341 =null;

        JavaTreeParser.expression_return expression349 =null;

        JavaTreeParser.statement_return statement353 =null;


        Object string_literal304_tree=null;
        Object char_literal306_tree=null;
        Object char_literal308_tree=null;
        Object string_literal309_tree=null;
        Object char_literal311_tree=null;
        Object char_literal313_tree=null;
        Object string_literal314_tree=null;
        Object string_literal317_tree=null;
        Object string_literal320_tree=null;
        Object string_literal323_tree=null;
        Object string_literal325_tree=null;
        Object char_literal327_tree=null;
        Object string_literal329_tree=null;
        Object char_literal331_tree=null;
        Object char_literal333_tree=null;
        Object string_literal334_tree=null;
        Object string_literal337_tree=null;
        Object char_literal339_tree=null;
        Object string_literal340_tree=null;
        Object char_literal342_tree=null;
        Object string_literal343_tree=null;
        Object IDENTIFIER344_tree=null;
        Object char_literal345_tree=null;
        Object string_literal346_tree=null;
        Object IDENTIFIER347_tree=null;
        Object char_literal348_tree=null;
        Object char_literal350_tree=null;
        Object IDENTIFIER351_tree=null;
        Object char_literal352_tree=null;
        Object char_literal354_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 58) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:932:5: ( block | ( 'assert' ) expression ( ':' expression )? ';' | 'assert' expression ( ':' expression )? ';' | 'if' parExpression statement ( 'else' statement )? | forstatement | 'while' parExpression statement | 'do' statement 'while' parExpression ';' | trystatement | 'switch' parExpression '{' switchBlockStatementGroups '}' | 'synchronized' parExpression block | 'return' ( expression )? ';' | 'throw' expression ';' | 'break' ( IDENTIFIER )? ';' | 'continue' ( IDENTIFIER )? ';' | expression ';' | IDENTIFIER ':' statement | ';' )
            int alt104=17;
            switch ( input.LA(1) ) {
            case LBRACE:
                {
                alt104=1;
                }
                break;
            case ASSERT:
                {
                int LA104_2 = input.LA(2);

                if ( (synpred139_JavaTree()) ) {
                    alt104=2;
                }
                else if ( (synpred141_JavaTree()) ) {
                    alt104=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 104, 2, input);

                    throw nvae;

                }
                }
                break;
            case IF:
                {
                alt104=4;
                }
                break;
            case FOR:
                {
                alt104=5;
                }
                break;
            case WHILE:
                {
                alt104=6;
                }
                break;
            case DO:
                {
                alt104=7;
                }
                break;
            case TRY:
                {
                alt104=8;
                }
                break;
            case SWITCH:
                {
                alt104=9;
                }
                break;
            case SYNCHRONIZED:
                {
                alt104=10;
                }
                break;
            case RETURN:
                {
                alt104=11;
                }
                break;
            case THROW:
                {
                alt104=12;
                }
                break;
            case BREAK:
                {
                alt104=13;
                }
                break;
            case CONTINUE:
                {
                alt104=14;
                }
                break;
            case BANG:
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CHARLITERAL:
            case DOUBLE:
            case DOUBLELITERAL:
            case FALSE:
            case FLOAT:
            case FLOATLITERAL:
            case INT:
            case INTLITERAL:
            case LONG:
            case LONGLITERAL:
            case LPAREN:
            case NEW:
            case NULL:
            case PLUS:
            case PLUSPLUS:
            case SHORT:
            case STRINGLITERAL:
            case SUB:
            case SUBSUB:
            case SUPER:
            case THIS:
            case TILDE:
            case TRUE:
            case VOID:
                {
                alt104=15;
                }
                break;
            case IDENTIFIER:
                {
                int LA104_22 = input.LA(2);

                if ( (synpred157_JavaTree()) ) {
                    alt104=15;
                }
                else if ( (synpred158_JavaTree()) ) {
                    alt104=16;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 104, 22, input);

                    throw nvae;

                }
                }
                break;
            case SEMI:
                {
                alt104=17;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 104, 0, input);

                throw nvae;

            }

            switch (alt104) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:932:9: block
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_block_in_statement5719);
                    block303=block();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, block303.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:934:9: ( 'assert' ) expression ( ':' expression )? ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:934:9: ( 'assert' )
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:934:10: 'assert'
                    {
                    string_literal304=(Token)match(input,ASSERT,FOLLOW_ASSERT_in_statement5743); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal304_tree = 
                    (Object)adaptor.create(string_literal304)
                    ;
                    adaptor.addChild(root_0, string_literal304_tree);
                    }

                    }


                    pushFollow(FOLLOW_expression_in_statement5763);
                    expression305=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression305.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:936:20: ( ':' expression )?
                    int alt98=2;
                    int LA98_0 = input.LA(1);

                    if ( (LA98_0==COLON) ) {
                        alt98=1;
                    }
                    switch (alt98) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:936:21: ':' expression
                            {
                            char_literal306=(Token)match(input,COLON,FOLLOW_COLON_in_statement5766); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            char_literal306_tree = 
                            (Object)adaptor.create(char_literal306)
                            ;
                            adaptor.addChild(root_0, char_literal306_tree);
                            }

                            pushFollow(FOLLOW_expression_in_statement5768);
                            expression307=expression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression307.getTree());

                            }
                            break;

                    }


                    char_literal308=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5772); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal308_tree = 
                    (Object)adaptor.create(char_literal308)
                    ;
                    adaptor.addChild(root_0, char_literal308_tree);
                    }

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:937:9: 'assert' expression ( ':' expression )? ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal309=(Token)match(input,ASSERT,FOLLOW_ASSERT_in_statement5782); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal309_tree = 
                    (Object)adaptor.create(string_literal309)
                    ;
                    adaptor.addChild(root_0, string_literal309_tree);
                    }

                    pushFollow(FOLLOW_expression_in_statement5785);
                    expression310=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression310.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:937:30: ( ':' expression )?
                    int alt99=2;
                    int LA99_0 = input.LA(1);

                    if ( (LA99_0==COLON) ) {
                        alt99=1;
                    }
                    switch (alt99) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:937:31: ':' expression
                            {
                            char_literal311=(Token)match(input,COLON,FOLLOW_COLON_in_statement5788); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            char_literal311_tree = 
                            (Object)adaptor.create(char_literal311)
                            ;
                            adaptor.addChild(root_0, char_literal311_tree);
                            }

                            pushFollow(FOLLOW_expression_in_statement5790);
                            expression312=expression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression312.getTree());

                            }
                            break;

                    }


                    char_literal313=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5794); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal313_tree = 
                    (Object)adaptor.create(char_literal313)
                    ;
                    adaptor.addChild(root_0, char_literal313_tree);
                    }

                    }
                    break;
                case 4 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:938:9: 'if' parExpression statement ( 'else' statement )?
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal314=(Token)match(input,IF,FOLLOW_IF_in_statement5816); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal314_tree = 
                    (Object)adaptor.create(string_literal314)
                    ;
                    adaptor.addChild(root_0, string_literal314_tree);
                    }

                    pushFollow(FOLLOW_parExpression_in_statement5818);
                    parExpression315=parExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression315.getTree());

                    pushFollow(FOLLOW_statement_in_statement5820);
                    statement316=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement316.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:938:38: ( 'else' statement )?
                    int alt100=2;
                    int LA100_0 = input.LA(1);

                    if ( (LA100_0==ELSE) ) {
                        int LA100_1 = input.LA(2);

                        if ( (synpred142_JavaTree()) ) {
                            alt100=1;
                        }
                    }
                    switch (alt100) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:938:39: 'else' statement
                            {
                            string_literal317=(Token)match(input,ELSE,FOLLOW_ELSE_in_statement5823); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            string_literal317_tree = 
                            (Object)adaptor.create(string_literal317)
                            ;
                            adaptor.addChild(root_0, string_literal317_tree);
                            }

                            pushFollow(FOLLOW_statement_in_statement5825);
                            statement318=statement();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, statement318.getTree());

                            }
                            break;

                    }


                    }
                    break;
                case 5 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:939:9: forstatement
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_forstatement_in_statement5847);
                    forstatement319=forstatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, forstatement319.getTree());

                    }
                    break;
                case 6 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:940:9: 'while' parExpression statement
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal320=(Token)match(input,WHILE,FOLLOW_WHILE_in_statement5857); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal320_tree = 
                    (Object)adaptor.create(string_literal320)
                    ;
                    adaptor.addChild(root_0, string_literal320_tree);
                    }

                    pushFollow(FOLLOW_parExpression_in_statement5859);
                    parExpression321=parExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression321.getTree());

                    pushFollow(FOLLOW_statement_in_statement5861);
                    statement322=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement322.getTree());

                    }
                    break;
                case 7 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:941:9: 'do' statement 'while' parExpression ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal323=(Token)match(input,DO,FOLLOW_DO_in_statement5871); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal323_tree = 
                    (Object)adaptor.create(string_literal323)
                    ;
                    adaptor.addChild(root_0, string_literal323_tree);
                    }

                    pushFollow(FOLLOW_statement_in_statement5873);
                    statement324=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement324.getTree());

                    string_literal325=(Token)match(input,WHILE,FOLLOW_WHILE_in_statement5875); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal325_tree = 
                    (Object)adaptor.create(string_literal325)
                    ;
                    adaptor.addChild(root_0, string_literal325_tree);
                    }

                    pushFollow(FOLLOW_parExpression_in_statement5877);
                    parExpression326=parExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression326.getTree());

                    char_literal327=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5879); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal327_tree = 
                    (Object)adaptor.create(char_literal327)
                    ;
                    adaptor.addChild(root_0, char_literal327_tree);
                    }

                    }
                    break;
                case 8 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:942:9: trystatement
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_trystatement_in_statement5889);
                    trystatement328=trystatement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, trystatement328.getTree());

                    }
                    break;
                case 9 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:943:9: 'switch' parExpression '{' switchBlockStatementGroups '}'
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal329=(Token)match(input,SWITCH,FOLLOW_SWITCH_in_statement5899); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal329_tree = 
                    (Object)adaptor.create(string_literal329)
                    ;
                    adaptor.addChild(root_0, string_literal329_tree);
                    }

                    pushFollow(FOLLOW_parExpression_in_statement5901);
                    parExpression330=parExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression330.getTree());

                    char_literal331=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_statement5903); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal331_tree = 
                    (Object)adaptor.create(char_literal331)
                    ;
                    adaptor.addChild(root_0, char_literal331_tree);
                    }

                    pushFollow(FOLLOW_switchBlockStatementGroups_in_statement5905);
                    switchBlockStatementGroups332=switchBlockStatementGroups();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, switchBlockStatementGroups332.getTree());

                    char_literal333=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_statement5907); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal333_tree = 
                    (Object)adaptor.create(char_literal333)
                    ;
                    adaptor.addChild(root_0, char_literal333_tree);
                    }

                    }
                    break;
                case 10 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:944:9: 'synchronized' parExpression block
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal334=(Token)match(input,SYNCHRONIZED,FOLLOW_SYNCHRONIZED_in_statement5917); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal334_tree = 
                    (Object)adaptor.create(string_literal334)
                    ;
                    adaptor.addChild(root_0, string_literal334_tree);
                    }

                    pushFollow(FOLLOW_parExpression_in_statement5919);
                    parExpression335=parExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression335.getTree());

                    pushFollow(FOLLOW_block_in_statement5921);
                    block336=block();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, block336.getTree());

                    }
                    break;
                case 11 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:945:9: 'return' ( expression )? ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal337=(Token)match(input,RETURN,FOLLOW_RETURN_in_statement5931); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal337_tree = 
                    (Object)adaptor.create(string_literal337)
                    ;
                    adaptor.addChild(root_0, string_literal337_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:945:18: ( expression )?
                    int alt101=2;
                    int LA101_0 = input.LA(1);

                    if ( (LA101_0==BANG||LA101_0==BOOLEAN||LA101_0==BYTE||(LA101_0 >= CHAR && LA101_0 <= CHARLITERAL)||(LA101_0 >= DOUBLE && LA101_0 <= DOUBLELITERAL)||LA101_0==FALSE||(LA101_0 >= FLOAT && LA101_0 <= FLOATLITERAL)||LA101_0==IDENTIFIER||LA101_0==INT||LA101_0==INTLITERAL||(LA101_0 >= LONG && LA101_0 <= LPAREN)||LA101_0==NEW||LA101_0==NULL||LA101_0==PLUS||LA101_0==PLUSPLUS||LA101_0==SHORT||(LA101_0 >= STRINGLITERAL && LA101_0 <= SUB)||(LA101_0 >= SUBSUB && LA101_0 <= SUPER)||LA101_0==THIS||LA101_0==TILDE||LA101_0==TRUE||LA101_0==VOID) ) {
                        alt101=1;
                    }
                    switch (alt101) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:945:19: expression
                            {
                            pushFollow(FOLLOW_expression_in_statement5934);
                            expression338=expression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression338.getTree());

                            }
                            break;

                    }


                    char_literal339=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5939); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal339_tree = 
                    (Object)adaptor.create(char_literal339)
                    ;
                    adaptor.addChild(root_0, char_literal339_tree);
                    }

                    }
                    break;
                case 12 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:946:9: 'throw' expression ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal340=(Token)match(input,THROW,FOLLOW_THROW_in_statement5949); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal340_tree = 
                    (Object)adaptor.create(string_literal340)
                    ;
                    adaptor.addChild(root_0, string_literal340_tree);
                    }

                    pushFollow(FOLLOW_expression_in_statement5951);
                    expression341=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression341.getTree());

                    char_literal342=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5953); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal342_tree = 
                    (Object)adaptor.create(char_literal342)
                    ;
                    adaptor.addChild(root_0, char_literal342_tree);
                    }

                    }
                    break;
                case 13 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:947:9: 'break' ( IDENTIFIER )? ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal343=(Token)match(input,BREAK,FOLLOW_BREAK_in_statement5963); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal343_tree = 
                    (Object)adaptor.create(string_literal343)
                    ;
                    adaptor.addChild(root_0, string_literal343_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:948:13: ( IDENTIFIER )?
                    int alt102=2;
                    int LA102_0 = input.LA(1);

                    if ( (LA102_0==IDENTIFIER) ) {
                        alt102=1;
                    }
                    switch (alt102) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:948:14: IDENTIFIER
                            {
                            IDENTIFIER344=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement5978); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            IDENTIFIER344_tree = 
                            (Object)adaptor.create(IDENTIFIER344)
                            ;
                            adaptor.addChild(root_0, IDENTIFIER344_tree);
                            }

                            }
                            break;

                    }


                    char_literal345=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement5995); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal345_tree = 
                    (Object)adaptor.create(char_literal345)
                    ;
                    adaptor.addChild(root_0, char_literal345_tree);
                    }

                    }
                    break;
                case 14 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:950:9: 'continue' ( IDENTIFIER )? ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal346=(Token)match(input,CONTINUE,FOLLOW_CONTINUE_in_statement6005); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal346_tree = 
                    (Object)adaptor.create(string_literal346)
                    ;
                    adaptor.addChild(root_0, string_literal346_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:951:13: ( IDENTIFIER )?
                    int alt103=2;
                    int LA103_0 = input.LA(1);

                    if ( (LA103_0==IDENTIFIER) ) {
                        alt103=1;
                    }
                    switch (alt103) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:951:14: IDENTIFIER
                            {
                            IDENTIFIER347=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement6020); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            IDENTIFIER347_tree = 
                            (Object)adaptor.create(IDENTIFIER347)
                            ;
                            adaptor.addChild(root_0, IDENTIFIER347_tree);
                            }

                            }
                            break;

                    }


                    char_literal348=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement6037); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal348_tree = 
                    (Object)adaptor.create(char_literal348)
                    ;
                    adaptor.addChild(root_0, char_literal348_tree);
                    }

                    }
                    break;
                case 15 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:953:9: expression ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_expression_in_statement6047);
                    expression349=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression349.getTree());

                    char_literal350=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement6050); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal350_tree = 
                    (Object)adaptor.create(char_literal350)
                    ;
                    adaptor.addChild(root_0, char_literal350_tree);
                    }

                    }
                    break;
                case 16 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:954:9: IDENTIFIER ':' statement
                    {
                    root_0 = (Object)adaptor.nil();


                    IDENTIFIER351=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_statement6065); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER351_tree = 
                    (Object)adaptor.create(IDENTIFIER351)
                    ;
                    adaptor.addChild(root_0, IDENTIFIER351_tree);
                    }

                    char_literal352=(Token)match(input,COLON,FOLLOW_COLON_in_statement6067); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal352_tree = 
                    (Object)adaptor.create(char_literal352)
                    ;
                    adaptor.addChild(root_0, char_literal352_tree);
                    }

                    pushFollow(FOLLOW_statement_in_statement6069);
                    statement353=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement353.getTree());

                    }
                    break;
                case 17 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:955:9: ';'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal354=(Token)match(input,SEMI,FOLLOW_SEMI_in_statement6079); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal354_tree = 
                    (Object)adaptor.create(char_literal354)
                    ;
                    adaptor.addChild(root_0, char_literal354_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 58, statement_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "statement"


    public static class switchBlockStatementGroups_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "switchBlockStatementGroups"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:959:1: switchBlockStatementGroups : ( switchBlockStatementGroup )* ;
    public final JavaTreeParser.switchBlockStatementGroups_return switchBlockStatementGroups() throws RecognitionException {
        JavaTreeParser.switchBlockStatementGroups_return retval = new JavaTreeParser.switchBlockStatementGroups_return();
        retval.start = input.LT(1);

        int switchBlockStatementGroups_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.switchBlockStatementGroup_return switchBlockStatementGroup355 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 59) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:960:5: ( ( switchBlockStatementGroup )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:960:9: ( switchBlockStatementGroup )*
            {
            root_0 = (Object)adaptor.nil();


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:960:9: ( switchBlockStatementGroup )*
            loop105:
            do {
                int alt105=2;
                int LA105_0 = input.LA(1);

                if ( (LA105_0==CASE||LA105_0==DEFAULT) ) {
                    alt105=1;
                }


                switch (alt105) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:960:10: switchBlockStatementGroup
            	    {
            	    pushFollow(FOLLOW_switchBlockStatementGroup_in_switchBlockStatementGroups6101);
            	    switchBlockStatementGroup355=switchBlockStatementGroup();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, switchBlockStatementGroup355.getTree());

            	    }
            	    break;

            	default :
            	    break loop105;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 59, switchBlockStatementGroups_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "switchBlockStatementGroups"


    public static class switchBlockStatementGroup_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "switchBlockStatementGroup"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:963:1: switchBlockStatementGroup : switchLabel ( blockStatement )* ;
    public final JavaTreeParser.switchBlockStatementGroup_return switchBlockStatementGroup() throws RecognitionException {
        JavaTreeParser.switchBlockStatementGroup_return retval = new JavaTreeParser.switchBlockStatementGroup_return();
        retval.start = input.LT(1);

        int switchBlockStatementGroup_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.switchLabel_return switchLabel356 =null;

        JavaTreeParser.blockStatement_return blockStatement357 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 60) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:964:5: ( switchLabel ( blockStatement )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:965:9: switchLabel ( blockStatement )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_switchLabel_in_switchBlockStatementGroup6130);
            switchLabel356=switchLabel();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, switchLabel356.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:966:9: ( blockStatement )*
            loop106:
            do {
                int alt106=2;
                int LA106_0 = input.LA(1);

                if ( (LA106_0==ABSTRACT||(LA106_0 >= ASSERT && LA106_0 <= BANG)||(LA106_0 >= BOOLEAN && LA106_0 <= BYTE)||(LA106_0 >= CHAR && LA106_0 <= CLASS)||LA106_0==CONTINUE||LA106_0==DO||(LA106_0 >= DOUBLE && LA106_0 <= DOUBLELITERAL)||LA106_0==ENUM||LA106_0==FALSE||LA106_0==FINAL||(LA106_0 >= FLOAT && LA106_0 <= FOR)||(LA106_0 >= IDENTIFIER && LA106_0 <= IF)||(LA106_0 >= INT && LA106_0 <= INTLITERAL)||LA106_0==LBRACE||(LA106_0 >= LONG && LA106_0 <= LT)||LA106_0==MONKEYS_AT||(LA106_0 >= NATIVE && LA106_0 <= NEW)||LA106_0==NULL||LA106_0==PLUS||(LA106_0 >= PLUSPLUS && LA106_0 <= PUBLIC)||LA106_0==RETURN||(LA106_0 >= SEMI && LA106_0 <= SHORT)||(LA106_0 >= STATIC && LA106_0 <= SUB)||(LA106_0 >= SUBSUB && LA106_0 <= SYNCHRONIZED)||(LA106_0 >= THIS && LA106_0 <= THROW)||(LA106_0 >= TILDE && LA106_0 <= TRY)||(LA106_0 >= VOID && LA106_0 <= WHILE)) ) {
                    alt106=1;
                }


                switch (alt106) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:966:10: blockStatement
            	    {
            	    pushFollow(FOLLOW_blockStatement_in_switchBlockStatementGroup6141);
            	    blockStatement357=blockStatement();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, blockStatement357.getTree());

            	    }
            	    break;

            	default :
            	    break loop106;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 60, switchBlockStatementGroup_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "switchBlockStatementGroup"


    public static class switchLabel_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "switchLabel"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:970:1: switchLabel : ( 'case' expression ':' | 'default' ':' );
    public final JavaTreeParser.switchLabel_return switchLabel() throws RecognitionException {
        JavaTreeParser.switchLabel_return retval = new JavaTreeParser.switchLabel_return();
        retval.start = input.LT(1);

        int switchLabel_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal358=null;
        Token char_literal360=null;
        Token string_literal361=null;
        Token char_literal362=null;
        JavaTreeParser.expression_return expression359 =null;


        Object string_literal358_tree=null;
        Object char_literal360_tree=null;
        Object string_literal361_tree=null;
        Object char_literal362_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 61) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:971:5: ( 'case' expression ':' | 'default' ':' )
            int alt107=2;
            int LA107_0 = input.LA(1);

            if ( (LA107_0==CASE) ) {
                alt107=1;
            }
            else if ( (LA107_0==DEFAULT) ) {
                alt107=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 107, 0, input);

                throw nvae;

            }
            switch (alt107) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:971:9: 'case' expression ':'
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal358=(Token)match(input,CASE,FOLLOW_CASE_in_switchLabel6172); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal358_tree = 
                    (Object)adaptor.create(string_literal358)
                    ;
                    adaptor.addChild(root_0, string_literal358_tree);
                    }

                    pushFollow(FOLLOW_expression_in_switchLabel6174);
                    expression359=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression359.getTree());

                    char_literal360=(Token)match(input,COLON,FOLLOW_COLON_in_switchLabel6176); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal360_tree = 
                    (Object)adaptor.create(char_literal360)
                    ;
                    adaptor.addChild(root_0, char_literal360_tree);
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:972:9: 'default' ':'
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal361=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_switchLabel6186); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal361_tree = 
                    (Object)adaptor.create(string_literal361)
                    ;
                    adaptor.addChild(root_0, string_literal361_tree);
                    }

                    char_literal362=(Token)match(input,COLON,FOLLOW_COLON_in_switchLabel6188); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal362_tree = 
                    (Object)adaptor.create(char_literal362)
                    ;
                    adaptor.addChild(root_0, char_literal362_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 61, switchLabel_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "switchLabel"


    public static class trystatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "trystatement"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:975:1: trystatement : ( 'try' block ( catches 'finally' block | catches | 'finally' block ) | 'try' resourceSpecification block ( catches 'finally' block | catches | 'finally' block )? );
    public final JavaTreeParser.trystatement_return trystatement() throws RecognitionException {
        JavaTreeParser.trystatement_return retval = new JavaTreeParser.trystatement_return();
        retval.start = input.LT(1);

        int trystatement_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal363=null;
        Token string_literal366=null;
        Token string_literal369=null;
        Token string_literal371=null;
        Token string_literal375=null;
        Token string_literal378=null;
        JavaTreeParser.block_return block364 =null;

        JavaTreeParser.catches_return catches365 =null;

        JavaTreeParser.block_return block367 =null;

        JavaTreeParser.catches_return catches368 =null;

        JavaTreeParser.block_return block370 =null;

        JavaTreeParser.resourceSpecification_return resourceSpecification372 =null;

        JavaTreeParser.block_return block373 =null;

        JavaTreeParser.catches_return catches374 =null;

        JavaTreeParser.block_return block376 =null;

        JavaTreeParser.catches_return catches377 =null;

        JavaTreeParser.block_return block379 =null;


        Object string_literal363_tree=null;
        Object string_literal366_tree=null;
        Object string_literal369_tree=null;
        Object string_literal371_tree=null;
        Object string_literal375_tree=null;
        Object string_literal378_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 62) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:976:5: ( 'try' block ( catches 'finally' block | catches | 'finally' block ) | 'try' resourceSpecification block ( catches 'finally' block | catches | 'finally' block )? )
            int alt110=2;
            int LA110_0 = input.LA(1);

            if ( (LA110_0==TRY) ) {
                int LA110_1 = input.LA(2);

                if ( (LA110_1==LBRACE) ) {
                    alt110=1;
                }
                else if ( (LA110_1==LPAREN) ) {
                    alt110=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 110, 1, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 110, 0, input);

                throw nvae;

            }
            switch (alt110) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:976:9: 'try' block ( catches 'finally' block | catches | 'finally' block )
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal363=(Token)match(input,TRY,FOLLOW_TRY_in_trystatement6208); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal363_tree = 
                    (Object)adaptor.create(string_literal363)
                    ;
                    adaptor.addChild(root_0, string_literal363_tree);
                    }

                    pushFollow(FOLLOW_block_in_trystatement6210);
                    block364=block();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, block364.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:977:9: ( catches 'finally' block | catches | 'finally' block )
                    int alt108=3;
                    int LA108_0 = input.LA(1);

                    if ( (LA108_0==CATCH) ) {
                        int LA108_1 = input.LA(2);

                        if ( (synpred162_JavaTree()) ) {
                            alt108=1;
                        }
                        else if ( (synpred163_JavaTree()) ) {
                            alt108=2;
                        }
                        else {
                            if (state.backtracking>0) {state.failed=true; return retval;}
                            NoViableAltException nvae =
                                new NoViableAltException("", 108, 1, input);

                            throw nvae;

                        }
                    }
                    else if ( (LA108_0==FINALLY) ) {
                        alt108=3;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 108, 0, input);

                        throw nvae;

                    }
                    switch (alt108) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:977:13: catches 'finally' block
                            {
                            pushFollow(FOLLOW_catches_in_trystatement6224);
                            catches365=catches();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, catches365.getTree());

                            string_literal366=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_trystatement6226); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            string_literal366_tree = 
                            (Object)adaptor.create(string_literal366)
                            ;
                            adaptor.addChild(root_0, string_literal366_tree);
                            }

                            pushFollow(FOLLOW_block_in_trystatement6228);
                            block367=block();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, block367.getTree());

                            }
                            break;
                        case 2 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:978:13: catches
                            {
                            pushFollow(FOLLOW_catches_in_trystatement6242);
                            catches368=catches();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, catches368.getTree());

                            }
                            break;
                        case 3 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:979:13: 'finally' block
                            {
                            string_literal369=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_trystatement6256); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            string_literal369_tree = 
                            (Object)adaptor.create(string_literal369)
                            ;
                            adaptor.addChild(root_0, string_literal369_tree);
                            }

                            pushFollow(FOLLOW_block_in_trystatement6258);
                            block370=block();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, block370.getTree());

                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:981:9: 'try' resourceSpecification block ( catches 'finally' block | catches | 'finally' block )?
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal371=(Token)match(input,TRY,FOLLOW_TRY_in_trystatement6278); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal371_tree = 
                    (Object)adaptor.create(string_literal371)
                    ;
                    adaptor.addChild(root_0, string_literal371_tree);
                    }

                    pushFollow(FOLLOW_resourceSpecification_in_trystatement6280);
                    resourceSpecification372=resourceSpecification();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, resourceSpecification372.getTree());

                    pushFollow(FOLLOW_block_in_trystatement6282);
                    block373=block();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, block373.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:982:5: ( catches 'finally' block | catches | 'finally' block )?
                    int alt109=4;
                    int LA109_0 = input.LA(1);

                    if ( (LA109_0==CATCH) ) {
                        int LA109_1 = input.LA(2);

                        if ( (synpred165_JavaTree()) ) {
                            alt109=1;
                        }
                        else if ( (synpred166_JavaTree()) ) {
                            alt109=2;
                        }
                    }
                    else if ( (LA109_0==FINALLY) ) {
                        alt109=3;
                    }
                    switch (alt109) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:982:9: catches 'finally' block
                            {
                            pushFollow(FOLLOW_catches_in_trystatement6292);
                            catches374=catches();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, catches374.getTree());

                            string_literal375=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_trystatement6294); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            string_literal375_tree = 
                            (Object)adaptor.create(string_literal375)
                            ;
                            adaptor.addChild(root_0, string_literal375_tree);
                            }

                            pushFollow(FOLLOW_block_in_trystatement6296);
                            block376=block();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, block376.getTree());

                            }
                            break;
                        case 2 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:983:13: catches
                            {
                            pushFollow(FOLLOW_catches_in_trystatement6310);
                            catches377=catches();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, catches377.getTree());

                            }
                            break;
                        case 3 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:984:13: 'finally' block
                            {
                            string_literal378=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_trystatement6324); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            string_literal378_tree = 
                            (Object)adaptor.create(string_literal378)
                            ;
                            adaptor.addChild(root_0, string_literal378_tree);
                            }

                            pushFollow(FOLLOW_block_in_trystatement6326);
                            block379=block();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, block379.getTree());

                            }
                            break;

                    }


                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 62, trystatement_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "trystatement"


    public static class resourceSpecification_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "resourceSpecification"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:988:1: resourceSpecification : '(' resource ( ';' resource )* ( ';' )? ')' ;
    public final JavaTreeParser.resourceSpecification_return resourceSpecification() throws RecognitionException {
        JavaTreeParser.resourceSpecification_return retval = new JavaTreeParser.resourceSpecification_return();
        retval.start = input.LT(1);

        int resourceSpecification_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal380=null;
        Token char_literal382=null;
        Token char_literal384=null;
        Token char_literal385=null;
        JavaTreeParser.resource_return resource381 =null;

        JavaTreeParser.resource_return resource383 =null;


        Object char_literal380_tree=null;
        Object char_literal382_tree=null;
        Object char_literal384_tree=null;
        Object char_literal385_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 63) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:989:4: ( '(' resource ( ';' resource )* ( ';' )? ')' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:989:6: '(' resource ( ';' resource )* ( ';' )? ')'
            {
            root_0 = (Object)adaptor.nil();


            char_literal380=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_resourceSpecification6359); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal380_tree = 
            (Object)adaptor.create(char_literal380)
            ;
            adaptor.addChild(root_0, char_literal380_tree);
            }

            pushFollow(FOLLOW_resource_in_resourceSpecification6361);
            resource381=resource();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, resource381.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:989:19: ( ';' resource )*
            loop111:
            do {
                int alt111=2;
                int LA111_0 = input.LA(1);

                if ( (LA111_0==SEMI) ) {
                    int LA111_1 = input.LA(2);

                    if ( (LA111_1==BOOLEAN||LA111_1==BYTE||LA111_1==CHAR||LA111_1==DOUBLE||LA111_1==FINAL||LA111_1==FLOAT||LA111_1==IDENTIFIER||LA111_1==INT||LA111_1==LONG||LA111_1==MONKEYS_AT||LA111_1==SHORT) ) {
                        alt111=1;
                    }


                }


                switch (alt111) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:989:20: ';' resource
            	    {
            	    char_literal382=(Token)match(input,SEMI,FOLLOW_SEMI_in_resourceSpecification6364); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal382_tree = 
            	    (Object)adaptor.create(char_literal382)
            	    ;
            	    adaptor.addChild(root_0, char_literal382_tree);
            	    }

            	    pushFollow(FOLLOW_resource_in_resourceSpecification6366);
            	    resource383=resource();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, resource383.getTree());

            	    }
            	    break;

            	default :
            	    break loop111;
                }
            } while (true);


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:989:35: ( ';' )?
            int alt112=2;
            int LA112_0 = input.LA(1);

            if ( (LA112_0==SEMI) ) {
                alt112=1;
            }
            switch (alt112) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:989:35: ';'
                    {
                    char_literal384=(Token)match(input,SEMI,FOLLOW_SEMI_in_resourceSpecification6370); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal384_tree = 
                    (Object)adaptor.create(char_literal384)
                    ;
                    adaptor.addChild(root_0, char_literal384_tree);
                    }

                    }
                    break;

            }


            char_literal385=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_resourceSpecification6373); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal385_tree = 
            (Object)adaptor.create(char_literal385)
            ;
            adaptor.addChild(root_0, char_literal385_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 63, resourceSpecification_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "resourceSpecification"


    public static class resource_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "resource"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:992:1: resource : variableModifiers type IDENTIFIER ( '[' ']' )* '=' expression ;
    public final JavaTreeParser.resource_return resource() throws RecognitionException {
        JavaTreeParser.resource_return retval = new JavaTreeParser.resource_return();
        retval.start = input.LT(1);

        int resource_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER388=null;
        Token char_literal389=null;
        Token char_literal390=null;
        Token char_literal391=null;
        JavaTreeParser.variableModifiers_return variableModifiers386 =null;

        JavaTreeParser.type_return type387 =null;

        JavaTreeParser.expression_return expression392 =null;


        Object IDENTIFIER388_tree=null;
        Object char_literal389_tree=null;
        Object char_literal390_tree=null;
        Object char_literal391_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 64) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:993:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* '=' expression )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:993:9: variableModifiers type IDENTIFIER ( '[' ']' )* '=' expression
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_variableModifiers_in_resource6391);
            variableModifiers386=variableModifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, variableModifiers386.getTree());

            pushFollow(FOLLOW_type_in_resource6398);
            type387=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, type387.getTree());

            IDENTIFIER388=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_resource6402); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER388_tree = 
            (Object)adaptor.create(IDENTIFIER388)
            ;
            adaptor.addChild(root_0, IDENTIFIER388_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:995:13: ( '[' ']' )*
            loop113:
            do {
                int alt113=2;
                int LA113_0 = input.LA(1);

                if ( (LA113_0==LBRACKET) ) {
                    alt113=1;
                }


                switch (alt113) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:995:14: '[' ']'
            	    {
            	    char_literal389=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_resource6405); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal389_tree = 
            	    (Object)adaptor.create(char_literal389)
            	    ;
            	    adaptor.addChild(root_0, char_literal389_tree);
            	    }

            	    char_literal390=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_resource6407); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal390_tree = 
            	    (Object)adaptor.create(char_literal390)
            	    ;
            	    adaptor.addChild(root_0, char_literal390_tree);
            	    }

            	    }
            	    break;

            	default :
            	    break loop113;
                }
            } while (true);


            char_literal391=(Token)match(input,EQ,FOLLOW_EQ_in_resource6412); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal391_tree = 
            (Object)adaptor.create(char_literal391)
            ;
            adaptor.addChild(root_0, char_literal391_tree);
            }

            pushFollow(FOLLOW_expression_in_resource6415);
            expression392=expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression392.getTree());

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 64, resource_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "resource"


    public static class catches_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "catches"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1000:1: catches : catchClause ( catchClause )* ;
    public final JavaTreeParser.catches_return catches() throws RecognitionException {
        JavaTreeParser.catches_return retval = new JavaTreeParser.catches_return();
        retval.start = input.LT(1);

        int catches_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.catchClause_return catchClause393 =null;

        JavaTreeParser.catchClause_return catchClause394 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 65) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1001:5: ( catchClause ( catchClause )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1001:9: catchClause ( catchClause )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_catchClause_in_catches6435);
            catchClause393=catchClause();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, catchClause393.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1002:9: ( catchClause )*
            loop114:
            do {
                int alt114=2;
                int LA114_0 = input.LA(1);

                if ( (LA114_0==CATCH) ) {
                    alt114=1;
                }


                switch (alt114) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1002:10: catchClause
            	    {
            	    pushFollow(FOLLOW_catchClause_in_catches6446);
            	    catchClause394=catchClause();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, catchClause394.getTree());

            	    }
            	    break;

            	default :
            	    break loop114;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 65, catches_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "catches"


    public static class catchClause_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "catchClause"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1006:1: catchClause : 'catch' '(' formalParameter ')' block ;
    public final JavaTreeParser.catchClause_return catchClause() throws RecognitionException {
        JavaTreeParser.catchClause_return retval = new JavaTreeParser.catchClause_return();
        retval.start = input.LT(1);

        int catchClause_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal395=null;
        Token char_literal396=null;
        Token char_literal398=null;
        JavaTreeParser.formalParameter_return formalParameter397 =null;

        JavaTreeParser.block_return block399 =null;


        Object string_literal395_tree=null;
        Object char_literal396_tree=null;
        Object char_literal398_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 66) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1007:5: ( 'catch' '(' formalParameter ')' block )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1007:9: 'catch' '(' formalParameter ')' block
            {
            root_0 = (Object)adaptor.nil();


            string_literal395=(Token)match(input,CATCH,FOLLOW_CATCH_in_catchClause6477); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            string_literal395_tree = 
            (Object)adaptor.create(string_literal395)
            ;
            adaptor.addChild(root_0, string_literal395_tree);
            }

            char_literal396=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_catchClause6479); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal396_tree = 
            (Object)adaptor.create(char_literal396)
            ;
            adaptor.addChild(root_0, char_literal396_tree);
            }

            pushFollow(FOLLOW_formalParameter_in_catchClause6481);
            formalParameter397=formalParameter();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, formalParameter397.getTree());

            char_literal398=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_catchClause6491); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal398_tree = 
            (Object)adaptor.create(char_literal398)
            ;
            adaptor.addChild(root_0, char_literal398_tree);
            }

            pushFollow(FOLLOW_block_in_catchClause6493);
            block399=block();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, block399.getTree());

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 66, catchClause_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "catchClause"


    public static class formalParameter_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "formalParameter"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1011:1: formalParameter : variableModifiers type ( '|' type )* IDENTIFIER ( '[' ']' )* ;
    public final JavaTreeParser.formalParameter_return formalParameter() throws RecognitionException {
        JavaTreeParser.formalParameter_return retval = new JavaTreeParser.formalParameter_return();
        retval.start = input.LT(1);

        int formalParameter_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal402=null;
        Token IDENTIFIER404=null;
        Token char_literal405=null;
        Token char_literal406=null;
        JavaTreeParser.variableModifiers_return variableModifiers400 =null;

        JavaTreeParser.type_return type401 =null;

        JavaTreeParser.type_return type403 =null;


        Object char_literal402_tree=null;
        Object IDENTIFIER404_tree=null;
        Object char_literal405_tree=null;
        Object char_literal406_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 67) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1012:5: ( variableModifiers type ( '|' type )* IDENTIFIER ( '[' ']' )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1012:9: variableModifiers type ( '|' type )* IDENTIFIER ( '[' ']' )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_variableModifiers_in_formalParameter6514);
            variableModifiers400=variableModifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, variableModifiers400.getTree());

            pushFollow(FOLLOW_type_in_formalParameter6516);
            type401=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, type401.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1012:32: ( '|' type )*
            loop115:
            do {
                int alt115=2;
                int LA115_0 = input.LA(1);

                if ( (LA115_0==BAR) ) {
                    alt115=1;
                }


                switch (alt115) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1012:33: '|' type
            	    {
            	    char_literal402=(Token)match(input,BAR,FOLLOW_BAR_in_formalParameter6519); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal402_tree = 
            	    (Object)adaptor.create(char_literal402)
            	    ;
            	    adaptor.addChild(root_0, char_literal402_tree);
            	    }

            	    pushFollow(FOLLOW_type_in_formalParameter6521);
            	    type403=type();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, type403.getTree());

            	    }
            	    break;

            	default :
            	    break loop115;
                }
            } while (true);


            IDENTIFIER404=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_formalParameter6525); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER404_tree = 
            (Object)adaptor.create(IDENTIFIER404)
            ;
            adaptor.addChild(root_0, IDENTIFIER404_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1013:9: ( '[' ']' )*
            loop116:
            do {
                int alt116=2;
                int LA116_0 = input.LA(1);

                if ( (LA116_0==LBRACKET) ) {
                    alt116=1;
                }


                switch (alt116) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1013:10: '[' ']'
            	    {
            	    char_literal405=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_formalParameter6536); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal405_tree = 
            	    (Object)adaptor.create(char_literal405)
            	    ;
            	    adaptor.addChild(root_0, char_literal405_tree);
            	    }

            	    char_literal406=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_formalParameter6538); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal406_tree = 
            	    (Object)adaptor.create(char_literal406)
            	    ;
            	    adaptor.addChild(root_0, char_literal406_tree);
            	    }

            	    }
            	    break;

            	default :
            	    break loop116;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 67, formalParameter_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "formalParameter"


    public static class forstatement_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "forstatement"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1017:1: forstatement : ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement | 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement );
    public final JavaTreeParser.forstatement_return forstatement() throws RecognitionException {
        JavaTreeParser.forstatement_return retval = new JavaTreeParser.forstatement_return();
        retval.start = input.LT(1);

        int forstatement_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal407=null;
        Token char_literal408=null;
        Token IDENTIFIER411=null;
        Token char_literal412=null;
        Token char_literal414=null;
        Token string_literal416=null;
        Token char_literal417=null;
        Token char_literal419=null;
        Token char_literal421=null;
        Token char_literal423=null;
        JavaTreeParser.variableModifiers_return variableModifiers409 =null;

        JavaTreeParser.type_return type410 =null;

        JavaTreeParser.expression_return expression413 =null;

        JavaTreeParser.statement_return statement415 =null;

        JavaTreeParser.forInit_return forInit418 =null;

        JavaTreeParser.expression_return expression420 =null;

        JavaTreeParser.expressionList_return expressionList422 =null;

        JavaTreeParser.statement_return statement424 =null;


        Object string_literal407_tree=null;
        Object char_literal408_tree=null;
        Object IDENTIFIER411_tree=null;
        Object char_literal412_tree=null;
        Object char_literal414_tree=null;
        Object string_literal416_tree=null;
        Object char_literal417_tree=null;
        Object char_literal419_tree=null;
        Object char_literal421_tree=null;
        Object char_literal423_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 68) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1018:5: ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement | 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement )
            int alt120=2;
            int LA120_0 = input.LA(1);

            if ( (LA120_0==FOR) ) {
                int LA120_1 = input.LA(2);

                if ( (synpred174_JavaTree()) ) {
                    alt120=1;
                }
                else if ( (true) ) {
                    alt120=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 120, 1, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 120, 0, input);

                throw nvae;

            }
            switch (alt120) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1020:9: 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal407=(Token)match(input,FOR,FOLLOW_FOR_in_forstatement6587); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal407_tree = 
                    (Object)adaptor.create(string_literal407)
                    ;
                    adaptor.addChild(root_0, string_literal407_tree);
                    }

                    char_literal408=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_forstatement6589); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal408_tree = 
                    (Object)adaptor.create(char_literal408)
                    ;
                    adaptor.addChild(root_0, char_literal408_tree);
                    }

                    pushFollow(FOLLOW_variableModifiers_in_forstatement6591);
                    variableModifiers409=variableModifiers();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, variableModifiers409.getTree());

                    pushFollow(FOLLOW_type_in_forstatement6593);
                    type410=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, type410.getTree());

                    IDENTIFIER411=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_forstatement6595); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER411_tree = 
                    (Object)adaptor.create(IDENTIFIER411)
                    ;
                    adaptor.addChild(root_0, IDENTIFIER411_tree);
                    }

                    char_literal412=(Token)match(input,COLON,FOLLOW_COLON_in_forstatement6597); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal412_tree = 
                    (Object)adaptor.create(char_literal412)
                    ;
                    adaptor.addChild(root_0, char_literal412_tree);
                    }

                    pushFollow(FOLLOW_expression_in_forstatement6608);
                    expression413=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression413.getTree());

                    char_literal414=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_forstatement6610); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal414_tree = 
                    (Object)adaptor.create(char_literal414)
                    ;
                    adaptor.addChild(root_0, char_literal414_tree);
                    }

                    pushFollow(FOLLOW_statement_in_forstatement6612);
                    statement415=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement415.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1024:9: 'for' '(' ( forInit )? ';' ( expression )? ';' ( expressionList )? ')' statement
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal416=(Token)match(input,FOR,FOLLOW_FOR_in_forstatement6644); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal416_tree = 
                    (Object)adaptor.create(string_literal416)
                    ;
                    adaptor.addChild(root_0, string_literal416_tree);
                    }

                    char_literal417=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_forstatement6646); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal417_tree = 
                    (Object)adaptor.create(char_literal417)
                    ;
                    adaptor.addChild(root_0, char_literal417_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1025:17: ( forInit )?
                    int alt117=2;
                    int LA117_0 = input.LA(1);

                    if ( (LA117_0==BANG||LA117_0==BOOLEAN||LA117_0==BYTE||(LA117_0 >= CHAR && LA117_0 <= CHARLITERAL)||(LA117_0 >= DOUBLE && LA117_0 <= DOUBLELITERAL)||LA117_0==FALSE||LA117_0==FINAL||(LA117_0 >= FLOAT && LA117_0 <= FLOATLITERAL)||LA117_0==IDENTIFIER||LA117_0==INT||LA117_0==INTLITERAL||(LA117_0 >= LONG && LA117_0 <= LPAREN)||LA117_0==MONKEYS_AT||LA117_0==NEW||LA117_0==NULL||LA117_0==PLUS||LA117_0==PLUSPLUS||LA117_0==SHORT||(LA117_0 >= STRINGLITERAL && LA117_0 <= SUB)||(LA117_0 >= SUBSUB && LA117_0 <= SUPER)||LA117_0==THIS||LA117_0==TILDE||LA117_0==TRUE||LA117_0==VOID) ) {
                        alt117=1;
                    }
                    switch (alt117) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1025:18: forInit
                            {
                            pushFollow(FOLLOW_forInit_in_forstatement6666);
                            forInit418=forInit();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, forInit418.getTree());

                            }
                            break;

                    }


                    char_literal419=(Token)match(input,SEMI,FOLLOW_SEMI_in_forstatement6687); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal419_tree = 
                    (Object)adaptor.create(char_literal419)
                    ;
                    adaptor.addChild(root_0, char_literal419_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1027:17: ( expression )?
                    int alt118=2;
                    int LA118_0 = input.LA(1);

                    if ( (LA118_0==BANG||LA118_0==BOOLEAN||LA118_0==BYTE||(LA118_0 >= CHAR && LA118_0 <= CHARLITERAL)||(LA118_0 >= DOUBLE && LA118_0 <= DOUBLELITERAL)||LA118_0==FALSE||(LA118_0 >= FLOAT && LA118_0 <= FLOATLITERAL)||LA118_0==IDENTIFIER||LA118_0==INT||LA118_0==INTLITERAL||(LA118_0 >= LONG && LA118_0 <= LPAREN)||LA118_0==NEW||LA118_0==NULL||LA118_0==PLUS||LA118_0==PLUSPLUS||LA118_0==SHORT||(LA118_0 >= STRINGLITERAL && LA118_0 <= SUB)||(LA118_0 >= SUBSUB && LA118_0 <= SUPER)||LA118_0==THIS||LA118_0==TILDE||LA118_0==TRUE||LA118_0==VOID) ) {
                        alt118=1;
                    }
                    switch (alt118) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1027:18: expression
                            {
                            pushFollow(FOLLOW_expression_in_forstatement6707);
                            expression420=expression();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression420.getTree());

                            }
                            break;

                    }


                    char_literal421=(Token)match(input,SEMI,FOLLOW_SEMI_in_forstatement6728); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal421_tree = 
                    (Object)adaptor.create(char_literal421)
                    ;
                    adaptor.addChild(root_0, char_literal421_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1029:17: ( expressionList )?
                    int alt119=2;
                    int LA119_0 = input.LA(1);

                    if ( (LA119_0==BANG||LA119_0==BOOLEAN||LA119_0==BYTE||(LA119_0 >= CHAR && LA119_0 <= CHARLITERAL)||(LA119_0 >= DOUBLE && LA119_0 <= DOUBLELITERAL)||LA119_0==FALSE||(LA119_0 >= FLOAT && LA119_0 <= FLOATLITERAL)||LA119_0==IDENTIFIER||LA119_0==INT||LA119_0==INTLITERAL||(LA119_0 >= LONG && LA119_0 <= LPAREN)||LA119_0==NEW||LA119_0==NULL||LA119_0==PLUS||LA119_0==PLUSPLUS||LA119_0==SHORT||(LA119_0 >= STRINGLITERAL && LA119_0 <= SUB)||(LA119_0 >= SUBSUB && LA119_0 <= SUPER)||LA119_0==THIS||LA119_0==TILDE||LA119_0==TRUE||LA119_0==VOID) ) {
                        alt119=1;
                    }
                    switch (alt119) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1029:18: expressionList
                            {
                            pushFollow(FOLLOW_expressionList_in_forstatement6748);
                            expressionList422=expressionList();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, expressionList422.getTree());

                            }
                            break;

                    }


                    char_literal423=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_forstatement6769); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal423_tree = 
                    (Object)adaptor.create(char_literal423)
                    ;
                    adaptor.addChild(root_0, char_literal423_tree);
                    }

                    pushFollow(FOLLOW_statement_in_forstatement6771);
                    statement424=statement();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, statement424.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 68, forstatement_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "forstatement"


    public static class forInit_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "forInit"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1033:1: forInit : ( localVariableDeclaration | expressionList );
    public final JavaTreeParser.forInit_return forInit() throws RecognitionException {
        JavaTreeParser.forInit_return retval = new JavaTreeParser.forInit_return();
        retval.start = input.LT(1);

        int forInit_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.localVariableDeclaration_return localVariableDeclaration425 =null;

        JavaTreeParser.expressionList_return expressionList426 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 69) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1034:5: ( localVariableDeclaration | expressionList )
            int alt121=2;
            switch ( input.LA(1) ) {
            case FINAL:
            case MONKEYS_AT:
                {
                alt121=1;
                }
                break;
            case IDENTIFIER:
                {
                int LA121_3 = input.LA(2);

                if ( (synpred178_JavaTree()) ) {
                    alt121=1;
                }
                else if ( (true) ) {
                    alt121=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 121, 3, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case INT:
            case LONG:
            case SHORT:
                {
                int LA121_4 = input.LA(2);

                if ( (synpred178_JavaTree()) ) {
                    alt121=1;
                }
                else if ( (true) ) {
                    alt121=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 121, 4, input);

                    throw nvae;

                }
                }
                break;
            case BANG:
            case CHARLITERAL:
            case DOUBLELITERAL:
            case FALSE:
            case FLOATLITERAL:
            case INTLITERAL:
            case LONGLITERAL:
            case LPAREN:
            case NEW:
            case NULL:
            case PLUS:
            case PLUSPLUS:
            case STRINGLITERAL:
            case SUB:
            case SUBSUB:
            case SUPER:
            case THIS:
            case TILDE:
            case TRUE:
            case VOID:
                {
                alt121=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 121, 0, input);

                throw nvae;

            }

            switch (alt121) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1034:9: localVariableDeclaration
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_localVariableDeclaration_in_forInit6791);
                    localVariableDeclaration425=localVariableDeclaration();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, localVariableDeclaration425.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1035:9: expressionList
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_expressionList_in_forInit6801);
                    expressionList426=expressionList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expressionList426.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 69, forInit_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "forInit"


    public static class parExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "parExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1038:1: parExpression : '(' expression ')' ;
    public final JavaTreeParser.parExpression_return parExpression() throws RecognitionException {
        JavaTreeParser.parExpression_return retval = new JavaTreeParser.parExpression_return();
        retval.start = input.LT(1);

        int parExpression_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal427=null;
        Token char_literal429=null;
        JavaTreeParser.expression_return expression428 =null;


        Object char_literal427_tree=null;
        Object char_literal429_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 70) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1039:5: ( '(' expression ')' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1039:9: '(' expression ')'
            {
            root_0 = (Object)adaptor.nil();


            char_literal427=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_parExpression6821); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal427_tree = 
            (Object)adaptor.create(char_literal427)
            ;
            adaptor.addChild(root_0, char_literal427_tree);
            }

            pushFollow(FOLLOW_expression_in_parExpression6823);
            expression428=expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression428.getTree());

            char_literal429=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_parExpression6825); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal429_tree = 
            (Object)adaptor.create(char_literal429)
            ;
            adaptor.addChild(root_0, char_literal429_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 70, parExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "parExpression"


    public static class expressionList_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expressionList"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1042:1: expressionList : expression ( ',' expression )* ;
    public final JavaTreeParser.expressionList_return expressionList() throws RecognitionException {
        JavaTreeParser.expressionList_return retval = new JavaTreeParser.expressionList_return();
        retval.start = input.LT(1);

        int expressionList_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal431=null;
        JavaTreeParser.expression_return expression430 =null;

        JavaTreeParser.expression_return expression432 =null;


        Object char_literal431_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 71) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1043:5: ( expression ( ',' expression )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1043:9: expression ( ',' expression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_expression_in_expressionList6845);
            expression430=expression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, expression430.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1044:9: ( ',' expression )*
            loop122:
            do {
                int alt122=2;
                int LA122_0 = input.LA(1);

                if ( (LA122_0==COMMA) ) {
                    alt122=1;
                }


                switch (alt122) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1044:10: ',' expression
            	    {
            	    char_literal431=(Token)match(input,COMMA,FOLLOW_COMMA_in_expressionList6856); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal431_tree = 
            	    (Object)adaptor.create(char_literal431)
            	    ;
            	    adaptor.addChild(root_0, char_literal431_tree);
            	    }

            	    pushFollow(FOLLOW_expression_in_expressionList6858);
            	    expression432=expression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression432.getTree());

            	    }
            	    break;

            	default :
            	    break loop122;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 71, expressionList_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "expressionList"


    public static class expression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "expression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1049:1: expression : conditionalExpression ( assignmentOperator expression )? ;
    public final JavaTreeParser.expression_return expression() throws RecognitionException {
        JavaTreeParser.expression_return retval = new JavaTreeParser.expression_return();
        retval.start = input.LT(1);

        int expression_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.conditionalExpression_return conditionalExpression433 =null;

        JavaTreeParser.assignmentOperator_return assignmentOperator434 =null;

        JavaTreeParser.expression_return expression435 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 72) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1050:5: ( conditionalExpression ( assignmentOperator expression )? )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1050:9: conditionalExpression ( assignmentOperator expression )?
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_conditionalExpression_in_expression6890);
            conditionalExpression433=conditionalExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalExpression433.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1051:9: ( assignmentOperator expression )?
            int alt123=2;
            int LA123_0 = input.LA(1);

            if ( (LA123_0==AMPEQ||LA123_0==BAREQ||LA123_0==CARETEQ||LA123_0==EQ||LA123_0==GT||LA123_0==LT||LA123_0==PERCENTEQ||LA123_0==PLUSEQ||LA123_0==SLASHEQ||LA123_0==STAREQ||LA123_0==SUBEQ) ) {
                alt123=1;
            }
            switch (alt123) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1051:10: assignmentOperator expression
                    {
                    pushFollow(FOLLOW_assignmentOperator_in_expression6901);
                    assignmentOperator434=assignmentOperator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, assignmentOperator434.getTree());

                    pushFollow(FOLLOW_expression_in_expression6903);
                    expression435=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression435.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 72, expression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "expression"


    public static class assignmentOperator_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "assignmentOperator"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1056:1: assignmentOperator : ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' );
    public final JavaTreeParser.assignmentOperator_return assignmentOperator() throws RecognitionException {
        JavaTreeParser.assignmentOperator_return retval = new JavaTreeParser.assignmentOperator_return();
        retval.start = input.LT(1);

        int assignmentOperator_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal436=null;
        Token string_literal437=null;
        Token string_literal438=null;
        Token string_literal439=null;
        Token string_literal440=null;
        Token string_literal441=null;
        Token string_literal442=null;
        Token string_literal443=null;
        Token string_literal444=null;
        Token char_literal445=null;
        Token char_literal446=null;
        Token char_literal447=null;
        Token char_literal448=null;
        Token char_literal449=null;
        Token char_literal450=null;
        Token char_literal451=null;
        Token char_literal452=null;
        Token char_literal453=null;
        Token char_literal454=null;

        Object char_literal436_tree=null;
        Object string_literal437_tree=null;
        Object string_literal438_tree=null;
        Object string_literal439_tree=null;
        Object string_literal440_tree=null;
        Object string_literal441_tree=null;
        Object string_literal442_tree=null;
        Object string_literal443_tree=null;
        Object string_literal444_tree=null;
        Object char_literal445_tree=null;
        Object char_literal446_tree=null;
        Object char_literal447_tree=null;
        Object char_literal448_tree=null;
        Object char_literal449_tree=null;
        Object char_literal450_tree=null;
        Object char_literal451_tree=null;
        Object char_literal452_tree=null;
        Object char_literal453_tree=null;
        Object char_literal454_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 73) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1057:5: ( '=' | '+=' | '-=' | '*=' | '/=' | '&=' | '|=' | '^=' | '%=' | '<' '<' '=' | '>' '>' '>' '=' | '>' '>' '=' )
            int alt124=12;
            switch ( input.LA(1) ) {
            case EQ:
                {
                alt124=1;
                }
                break;
            case PLUSEQ:
                {
                alt124=2;
                }
                break;
            case SUBEQ:
                {
                alt124=3;
                }
                break;
            case STAREQ:
                {
                alt124=4;
                }
                break;
            case SLASHEQ:
                {
                alt124=5;
                }
                break;
            case AMPEQ:
                {
                alt124=6;
                }
                break;
            case BAREQ:
                {
                alt124=7;
                }
                break;
            case CARETEQ:
                {
                alt124=8;
                }
                break;
            case PERCENTEQ:
                {
                alt124=9;
                }
                break;
            case LT:
                {
                alt124=10;
                }
                break;
            case GT:
                {
                int LA124_11 = input.LA(2);

                if ( (LA124_11==GT) ) {
                    int LA124_12 = input.LA(3);

                    if ( (LA124_12==GT) ) {
                        alt124=11;
                    }
                    else if ( (LA124_12==EQ) ) {
                        alt124=12;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 124, 12, input);

                        throw nvae;

                    }
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 124, 11, input);

                    throw nvae;

                }
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 124, 0, input);

                throw nvae;

            }

            switch (alt124) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1057:9: '='
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal436=(Token)match(input,EQ,FOLLOW_EQ_in_assignmentOperator6935); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal436_tree = 
                    (Object)adaptor.create(char_literal436)
                    ;
                    adaptor.addChild(root_0, char_literal436_tree);
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1058:9: '+='
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal437=(Token)match(input,PLUSEQ,FOLLOW_PLUSEQ_in_assignmentOperator6945); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal437_tree = 
                    (Object)adaptor.create(string_literal437)
                    ;
                    adaptor.addChild(root_0, string_literal437_tree);
                    }

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1059:9: '-='
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal438=(Token)match(input,SUBEQ,FOLLOW_SUBEQ_in_assignmentOperator6955); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal438_tree = 
                    (Object)adaptor.create(string_literal438)
                    ;
                    adaptor.addChild(root_0, string_literal438_tree);
                    }

                    }
                    break;
                case 4 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1060:9: '*='
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal439=(Token)match(input,STAREQ,FOLLOW_STAREQ_in_assignmentOperator6965); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal439_tree = 
                    (Object)adaptor.create(string_literal439)
                    ;
                    adaptor.addChild(root_0, string_literal439_tree);
                    }

                    }
                    break;
                case 5 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1061:9: '/='
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal440=(Token)match(input,SLASHEQ,FOLLOW_SLASHEQ_in_assignmentOperator6975); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal440_tree = 
                    (Object)adaptor.create(string_literal440)
                    ;
                    adaptor.addChild(root_0, string_literal440_tree);
                    }

                    }
                    break;
                case 6 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1062:9: '&='
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal441=(Token)match(input,AMPEQ,FOLLOW_AMPEQ_in_assignmentOperator6985); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal441_tree = 
                    (Object)adaptor.create(string_literal441)
                    ;
                    adaptor.addChild(root_0, string_literal441_tree);
                    }

                    }
                    break;
                case 7 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1063:9: '|='
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal442=(Token)match(input,BAREQ,FOLLOW_BAREQ_in_assignmentOperator6995); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal442_tree = 
                    (Object)adaptor.create(string_literal442)
                    ;
                    adaptor.addChild(root_0, string_literal442_tree);
                    }

                    }
                    break;
                case 8 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1064:9: '^='
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal443=(Token)match(input,CARETEQ,FOLLOW_CARETEQ_in_assignmentOperator7005); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal443_tree = 
                    (Object)adaptor.create(string_literal443)
                    ;
                    adaptor.addChild(root_0, string_literal443_tree);
                    }

                    }
                    break;
                case 9 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1065:9: '%='
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal444=(Token)match(input,PERCENTEQ,FOLLOW_PERCENTEQ_in_assignmentOperator7015); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal444_tree = 
                    (Object)adaptor.create(string_literal444)
                    ;
                    adaptor.addChild(root_0, string_literal444_tree);
                    }

                    }
                    break;
                case 10 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1066:10: '<' '<' '='
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal445=(Token)match(input,LT,FOLLOW_LT_in_assignmentOperator7026); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal445_tree = 
                    (Object)adaptor.create(char_literal445)
                    ;
                    adaptor.addChild(root_0, char_literal445_tree);
                    }

                    char_literal446=(Token)match(input,LT,FOLLOW_LT_in_assignmentOperator7028); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal446_tree = 
                    (Object)adaptor.create(char_literal446)
                    ;
                    adaptor.addChild(root_0, char_literal446_tree);
                    }

                    char_literal447=(Token)match(input,EQ,FOLLOW_EQ_in_assignmentOperator7030); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal447_tree = 
                    (Object)adaptor.create(char_literal447)
                    ;
                    adaptor.addChild(root_0, char_literal447_tree);
                    }

                    }
                    break;
                case 11 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1067:10: '>' '>' '>' '='
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal448=(Token)match(input,GT,FOLLOW_GT_in_assignmentOperator7041); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal448_tree = 
                    (Object)adaptor.create(char_literal448)
                    ;
                    adaptor.addChild(root_0, char_literal448_tree);
                    }

                    char_literal449=(Token)match(input,GT,FOLLOW_GT_in_assignmentOperator7043); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal449_tree = 
                    (Object)adaptor.create(char_literal449)
                    ;
                    adaptor.addChild(root_0, char_literal449_tree);
                    }

                    char_literal450=(Token)match(input,GT,FOLLOW_GT_in_assignmentOperator7045); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal450_tree = 
                    (Object)adaptor.create(char_literal450)
                    ;
                    adaptor.addChild(root_0, char_literal450_tree);
                    }

                    char_literal451=(Token)match(input,EQ,FOLLOW_EQ_in_assignmentOperator7047); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal451_tree = 
                    (Object)adaptor.create(char_literal451)
                    ;
                    adaptor.addChild(root_0, char_literal451_tree);
                    }

                    }
                    break;
                case 12 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1068:10: '>' '>' '='
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal452=(Token)match(input,GT,FOLLOW_GT_in_assignmentOperator7058); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal452_tree = 
                    (Object)adaptor.create(char_literal452)
                    ;
                    adaptor.addChild(root_0, char_literal452_tree);
                    }

                    char_literal453=(Token)match(input,GT,FOLLOW_GT_in_assignmentOperator7060); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal453_tree = 
                    (Object)adaptor.create(char_literal453)
                    ;
                    adaptor.addChild(root_0, char_literal453_tree);
                    }

                    char_literal454=(Token)match(input,EQ,FOLLOW_EQ_in_assignmentOperator7062); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal454_tree = 
                    (Object)adaptor.create(char_literal454)
                    ;
                    adaptor.addChild(root_0, char_literal454_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 73, assignmentOperator_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "assignmentOperator"


    public static class conditionalExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "conditionalExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1072:1: conditionalExpression : conditionalOrExpression ( '?' expression ':' conditionalExpression )? ;
    public final JavaTreeParser.conditionalExpression_return conditionalExpression() throws RecognitionException {
        JavaTreeParser.conditionalExpression_return retval = new JavaTreeParser.conditionalExpression_return();
        retval.start = input.LT(1);

        int conditionalExpression_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal456=null;
        Token char_literal458=null;
        JavaTreeParser.conditionalOrExpression_return conditionalOrExpression455 =null;

        JavaTreeParser.expression_return expression457 =null;

        JavaTreeParser.conditionalExpression_return conditionalExpression459 =null;


        Object char_literal456_tree=null;
        Object char_literal458_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 74) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1073:5: ( conditionalOrExpression ( '?' expression ':' conditionalExpression )? )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1073:9: conditionalOrExpression ( '?' expression ':' conditionalExpression )?
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_conditionalOrExpression_in_conditionalExpression7083);
            conditionalOrExpression455=conditionalOrExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalOrExpression455.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1074:9: ( '?' expression ':' conditionalExpression )?
            int alt125=2;
            int LA125_0 = input.LA(1);

            if ( (LA125_0==QUES) ) {
                alt125=1;
            }
            switch (alt125) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1074:10: '?' expression ':' conditionalExpression
                    {
                    char_literal456=(Token)match(input,QUES,FOLLOW_QUES_in_conditionalExpression7094); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal456_tree = 
                    (Object)adaptor.create(char_literal456)
                    ;
                    adaptor.addChild(root_0, char_literal456_tree);
                    }

                    pushFollow(FOLLOW_expression_in_conditionalExpression7096);
                    expression457=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression457.getTree());

                    char_literal458=(Token)match(input,COLON,FOLLOW_COLON_in_conditionalExpression7098); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal458_tree = 
                    (Object)adaptor.create(char_literal458)
                    ;
                    adaptor.addChild(root_0, char_literal458_tree);
                    }

                    pushFollow(FOLLOW_conditionalExpression_in_conditionalExpression7100);
                    conditionalExpression459=conditionalExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalExpression459.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 74, conditionalExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "conditionalExpression"


    public static class conditionalOrExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "conditionalOrExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1078:1: conditionalOrExpression : conditionalAndExpression ( '||' conditionalAndExpression )* ;
    public final JavaTreeParser.conditionalOrExpression_return conditionalOrExpression() throws RecognitionException {
        JavaTreeParser.conditionalOrExpression_return retval = new JavaTreeParser.conditionalOrExpression_return();
        retval.start = input.LT(1);

        int conditionalOrExpression_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal461=null;
        JavaTreeParser.conditionalAndExpression_return conditionalAndExpression460 =null;

        JavaTreeParser.conditionalAndExpression_return conditionalAndExpression462 =null;


        Object string_literal461_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 75) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1079:5: ( conditionalAndExpression ( '||' conditionalAndExpression )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1079:9: conditionalAndExpression ( '||' conditionalAndExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression7131);
            conditionalAndExpression460=conditionalAndExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalAndExpression460.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1080:9: ( '||' conditionalAndExpression )*
            loop126:
            do {
                int alt126=2;
                int LA126_0 = input.LA(1);

                if ( (LA126_0==BARBAR) ) {
                    alt126=1;
                }


                switch (alt126) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1080:10: '||' conditionalAndExpression
            	    {
            	    string_literal461=(Token)match(input,BARBAR,FOLLOW_BARBAR_in_conditionalOrExpression7142); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal461_tree = 
            	    (Object)adaptor.create(string_literal461)
            	    ;
            	    adaptor.addChild(root_0, string_literal461_tree);
            	    }

            	    pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression7144);
            	    conditionalAndExpression462=conditionalAndExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, conditionalAndExpression462.getTree());

            	    }
            	    break;

            	default :
            	    break loop126;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 75, conditionalOrExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "conditionalOrExpression"


    public static class conditionalAndExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "conditionalAndExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1084:1: conditionalAndExpression : inclusiveOrExpression ( '&&' inclusiveOrExpression )* ;
    public final JavaTreeParser.conditionalAndExpression_return conditionalAndExpression() throws RecognitionException {
        JavaTreeParser.conditionalAndExpression_return retval = new JavaTreeParser.conditionalAndExpression_return();
        retval.start = input.LT(1);

        int conditionalAndExpression_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal464=null;
        JavaTreeParser.inclusiveOrExpression_return inclusiveOrExpression463 =null;

        JavaTreeParser.inclusiveOrExpression_return inclusiveOrExpression465 =null;


        Object string_literal464_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 76) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1085:5: ( inclusiveOrExpression ( '&&' inclusiveOrExpression )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1085:9: inclusiveOrExpression ( '&&' inclusiveOrExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression7175);
            inclusiveOrExpression463=inclusiveOrExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, inclusiveOrExpression463.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1086:9: ( '&&' inclusiveOrExpression )*
            loop127:
            do {
                int alt127=2;
                int LA127_0 = input.LA(1);

                if ( (LA127_0==AMPAMP) ) {
                    alt127=1;
                }


                switch (alt127) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1086:10: '&&' inclusiveOrExpression
            	    {
            	    string_literal464=(Token)match(input,AMPAMP,FOLLOW_AMPAMP_in_conditionalAndExpression7186); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    string_literal464_tree = 
            	    (Object)adaptor.create(string_literal464)
            	    ;
            	    adaptor.addChild(root_0, string_literal464_tree);
            	    }

            	    pushFollow(FOLLOW_inclusiveOrExpression_in_conditionalAndExpression7188);
            	    inclusiveOrExpression465=inclusiveOrExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, inclusiveOrExpression465.getTree());

            	    }
            	    break;

            	default :
            	    break loop127;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 76, conditionalAndExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "conditionalAndExpression"


    public static class inclusiveOrExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "inclusiveOrExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1090:1: inclusiveOrExpression : exclusiveOrExpression ( '|' exclusiveOrExpression )* ;
    public final JavaTreeParser.inclusiveOrExpression_return inclusiveOrExpression() throws RecognitionException {
        JavaTreeParser.inclusiveOrExpression_return retval = new JavaTreeParser.inclusiveOrExpression_return();
        retval.start = input.LT(1);

        int inclusiveOrExpression_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal467=null;
        JavaTreeParser.exclusiveOrExpression_return exclusiveOrExpression466 =null;

        JavaTreeParser.exclusiveOrExpression_return exclusiveOrExpression468 =null;


        Object char_literal467_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 77) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1091:5: ( exclusiveOrExpression ( '|' exclusiveOrExpression )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1091:9: exclusiveOrExpression ( '|' exclusiveOrExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression7219);
            exclusiveOrExpression466=exclusiveOrExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, exclusiveOrExpression466.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1092:9: ( '|' exclusiveOrExpression )*
            loop128:
            do {
                int alt128=2;
                int LA128_0 = input.LA(1);

                if ( (LA128_0==BAR) ) {
                    alt128=1;
                }


                switch (alt128) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1092:10: '|' exclusiveOrExpression
            	    {
            	    char_literal467=(Token)match(input,BAR,FOLLOW_BAR_in_inclusiveOrExpression7230); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal467_tree = 
            	    (Object)adaptor.create(char_literal467)
            	    ;
            	    adaptor.addChild(root_0, char_literal467_tree);
            	    }

            	    pushFollow(FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression7232);
            	    exclusiveOrExpression468=exclusiveOrExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, exclusiveOrExpression468.getTree());

            	    }
            	    break;

            	default :
            	    break loop128;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 77, inclusiveOrExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "inclusiveOrExpression"


    public static class exclusiveOrExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "exclusiveOrExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1096:1: exclusiveOrExpression : andExpression ( '^' andExpression )* ;
    public final JavaTreeParser.exclusiveOrExpression_return exclusiveOrExpression() throws RecognitionException {
        JavaTreeParser.exclusiveOrExpression_return retval = new JavaTreeParser.exclusiveOrExpression_return();
        retval.start = input.LT(1);

        int exclusiveOrExpression_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal470=null;
        JavaTreeParser.andExpression_return andExpression469 =null;

        JavaTreeParser.andExpression_return andExpression471 =null;


        Object char_literal470_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 78) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1097:5: ( andExpression ( '^' andExpression )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1097:9: andExpression ( '^' andExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression7263);
            andExpression469=andExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, andExpression469.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1098:9: ( '^' andExpression )*
            loop129:
            do {
                int alt129=2;
                int LA129_0 = input.LA(1);

                if ( (LA129_0==CARET) ) {
                    alt129=1;
                }


                switch (alt129) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1098:10: '^' andExpression
            	    {
            	    char_literal470=(Token)match(input,CARET,FOLLOW_CARET_in_exclusiveOrExpression7274); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal470_tree = 
            	    (Object)adaptor.create(char_literal470)
            	    ;
            	    adaptor.addChild(root_0, char_literal470_tree);
            	    }

            	    pushFollow(FOLLOW_andExpression_in_exclusiveOrExpression7276);
            	    andExpression471=andExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, andExpression471.getTree());

            	    }
            	    break;

            	default :
            	    break loop129;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 78, exclusiveOrExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "exclusiveOrExpression"


    public static class andExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "andExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1102:1: andExpression : equalityExpression ( '&' equalityExpression )* ;
    public final JavaTreeParser.andExpression_return andExpression() throws RecognitionException {
        JavaTreeParser.andExpression_return retval = new JavaTreeParser.andExpression_return();
        retval.start = input.LT(1);

        int andExpression_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal473=null;
        JavaTreeParser.equalityExpression_return equalityExpression472 =null;

        JavaTreeParser.equalityExpression_return equalityExpression474 =null;


        Object char_literal473_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 79) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1103:5: ( equalityExpression ( '&' equalityExpression )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1103:9: equalityExpression ( '&' equalityExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_equalityExpression_in_andExpression7307);
            equalityExpression472=equalityExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, equalityExpression472.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1104:9: ( '&' equalityExpression )*
            loop130:
            do {
                int alt130=2;
                int LA130_0 = input.LA(1);

                if ( (LA130_0==AMP) ) {
                    alt130=1;
                }


                switch (alt130) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1104:10: '&' equalityExpression
            	    {
            	    char_literal473=(Token)match(input,AMP,FOLLOW_AMP_in_andExpression7318); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal473_tree = 
            	    (Object)adaptor.create(char_literal473)
            	    ;
            	    adaptor.addChild(root_0, char_literal473_tree);
            	    }

            	    pushFollow(FOLLOW_equalityExpression_in_andExpression7320);
            	    equalityExpression474=equalityExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, equalityExpression474.getTree());

            	    }
            	    break;

            	default :
            	    break loop130;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 79, andExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "andExpression"


    public static class equalityExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "equalityExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1108:1: equalityExpression : instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* ;
    public final JavaTreeParser.equalityExpression_return equalityExpression() throws RecognitionException {
        JavaTreeParser.equalityExpression_return retval = new JavaTreeParser.equalityExpression_return();
        retval.start = input.LT(1);

        int equalityExpression_StartIndex = input.index();

        Object root_0 = null;

        Token set476=null;
        JavaTreeParser.instanceOfExpression_return instanceOfExpression475 =null;

        JavaTreeParser.instanceOfExpression_return instanceOfExpression477 =null;


        Object set476_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 80) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1109:5: ( instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1109:9: instanceOfExpression ( ( '==' | '!=' ) instanceOfExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression7351);
            instanceOfExpression475=instanceOfExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, instanceOfExpression475.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1110:9: ( ( '==' | '!=' ) instanceOfExpression )*
            loop131:
            do {
                int alt131=2;
                int LA131_0 = input.LA(1);

                if ( (LA131_0==BANGEQ||LA131_0==EQEQ) ) {
                    alt131=1;
                }


                switch (alt131) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1111:13: ( '==' | '!=' ) instanceOfExpression
            	    {
            	    set476=(Token)input.LT(1);

            	    if ( input.LA(1)==BANGEQ||input.LA(1)==EQEQ ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, 
            	        (Object)adaptor.create(set476)
            	        );
            	        state.errorRecovery=false;
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_instanceOfExpression_in_equalityExpression7428);
            	    instanceOfExpression477=instanceOfExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, instanceOfExpression477.getTree());

            	    }
            	    break;

            	default :
            	    break loop131;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 80, equalityExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "equalityExpression"


    public static class instanceOfExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "instanceOfExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1118:1: instanceOfExpression : relationalExpression ( 'instanceof' type )? ;
    public final JavaTreeParser.instanceOfExpression_return instanceOfExpression() throws RecognitionException {
        JavaTreeParser.instanceOfExpression_return retval = new JavaTreeParser.instanceOfExpression_return();
        retval.start = input.LT(1);

        int instanceOfExpression_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal479=null;
        JavaTreeParser.relationalExpression_return relationalExpression478 =null;

        JavaTreeParser.type_return type480 =null;


        Object string_literal479_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 81) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1119:5: ( relationalExpression ( 'instanceof' type )? )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1119:9: relationalExpression ( 'instanceof' type )?
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_relationalExpression_in_instanceOfExpression7459);
            relationalExpression478=relationalExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, relationalExpression478.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1120:9: ( 'instanceof' type )?
            int alt132=2;
            int LA132_0 = input.LA(1);

            if ( (LA132_0==INSTANCEOF) ) {
                alt132=1;
            }
            switch (alt132) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1120:10: 'instanceof' type
                    {
                    string_literal479=(Token)match(input,INSTANCEOF,FOLLOW_INSTANCEOF_in_instanceOfExpression7470); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal479_tree = 
                    (Object)adaptor.create(string_literal479)
                    ;
                    adaptor.addChild(root_0, string_literal479_tree);
                    }

                    pushFollow(FOLLOW_type_in_instanceOfExpression7472);
                    type480=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, type480.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 81, instanceOfExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "instanceOfExpression"


    public static class relationalExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "relationalExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1124:1: relationalExpression : shiftExpression ( relationalOp shiftExpression )* ;
    public final JavaTreeParser.relationalExpression_return relationalExpression() throws RecognitionException {
        JavaTreeParser.relationalExpression_return retval = new JavaTreeParser.relationalExpression_return();
        retval.start = input.LT(1);

        int relationalExpression_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.shiftExpression_return shiftExpression481 =null;

        JavaTreeParser.relationalOp_return relationalOp482 =null;

        JavaTreeParser.shiftExpression_return shiftExpression483 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 82) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1125:5: ( shiftExpression ( relationalOp shiftExpression )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1125:9: shiftExpression ( relationalOp shiftExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_shiftExpression_in_relationalExpression7503);
            shiftExpression481=shiftExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, shiftExpression481.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1126:9: ( relationalOp shiftExpression )*
            loop133:
            do {
                int alt133=2;
                int LA133_0 = input.LA(1);

                if ( (LA133_0==LT) ) {
                    int LA133_2 = input.LA(2);

                    if ( (LA133_2==BANG||LA133_2==BOOLEAN||LA133_2==BYTE||(LA133_2 >= CHAR && LA133_2 <= CHARLITERAL)||(LA133_2 >= DOUBLE && LA133_2 <= DOUBLELITERAL)||LA133_2==EQ||LA133_2==FALSE||(LA133_2 >= FLOAT && LA133_2 <= FLOATLITERAL)||LA133_2==IDENTIFIER||LA133_2==INT||LA133_2==INTLITERAL||(LA133_2 >= LONG && LA133_2 <= LPAREN)||LA133_2==NEW||LA133_2==NULL||LA133_2==PLUS||LA133_2==PLUSPLUS||LA133_2==SHORT||(LA133_2 >= STRINGLITERAL && LA133_2 <= SUB)||(LA133_2 >= SUBSUB && LA133_2 <= SUPER)||LA133_2==THIS||LA133_2==TILDE||LA133_2==TRUE||LA133_2==VOID) ) {
                        alt133=1;
                    }


                }
                else if ( (LA133_0==GT) ) {
                    int LA133_3 = input.LA(2);

                    if ( (LA133_3==BANG||LA133_3==BOOLEAN||LA133_3==BYTE||(LA133_3 >= CHAR && LA133_3 <= CHARLITERAL)||(LA133_3 >= DOUBLE && LA133_3 <= DOUBLELITERAL)||LA133_3==EQ||LA133_3==FALSE||(LA133_3 >= FLOAT && LA133_3 <= FLOATLITERAL)||LA133_3==IDENTIFIER||LA133_3==INT||LA133_3==INTLITERAL||(LA133_3 >= LONG && LA133_3 <= LPAREN)||LA133_3==NEW||LA133_3==NULL||LA133_3==PLUS||LA133_3==PLUSPLUS||LA133_3==SHORT||(LA133_3 >= STRINGLITERAL && LA133_3 <= SUB)||(LA133_3 >= SUBSUB && LA133_3 <= SUPER)||LA133_3==THIS||LA133_3==TILDE||LA133_3==TRUE||LA133_3==VOID) ) {
                        alt133=1;
                    }


                }


                switch (alt133) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1126:10: relationalOp shiftExpression
            	    {
            	    pushFollow(FOLLOW_relationalOp_in_relationalExpression7514);
            	    relationalOp482=relationalOp();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, relationalOp482.getTree());

            	    pushFollow(FOLLOW_shiftExpression_in_relationalExpression7516);
            	    shiftExpression483=shiftExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, shiftExpression483.getTree());

            	    }
            	    break;

            	default :
            	    break loop133;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 82, relationalExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "relationalExpression"


    public static class relationalOp_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "relationalOp"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1130:1: relationalOp : ( '<' '=' | '>' '=' | '<' | '>' );
    public final JavaTreeParser.relationalOp_return relationalOp() throws RecognitionException {
        JavaTreeParser.relationalOp_return retval = new JavaTreeParser.relationalOp_return();
        retval.start = input.LT(1);

        int relationalOp_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal484=null;
        Token char_literal485=null;
        Token char_literal486=null;
        Token char_literal487=null;
        Token char_literal488=null;
        Token char_literal489=null;

        Object char_literal484_tree=null;
        Object char_literal485_tree=null;
        Object char_literal486_tree=null;
        Object char_literal487_tree=null;
        Object char_literal488_tree=null;
        Object char_literal489_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 83) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1131:5: ( '<' '=' | '>' '=' | '<' | '>' )
            int alt134=4;
            int LA134_0 = input.LA(1);

            if ( (LA134_0==LT) ) {
                int LA134_1 = input.LA(2);

                if ( (LA134_1==EQ) ) {
                    alt134=1;
                }
                else if ( (LA134_1==BANG||LA134_1==BOOLEAN||LA134_1==BYTE||(LA134_1 >= CHAR && LA134_1 <= CHARLITERAL)||(LA134_1 >= DOUBLE && LA134_1 <= DOUBLELITERAL)||LA134_1==FALSE||(LA134_1 >= FLOAT && LA134_1 <= FLOATLITERAL)||LA134_1==IDENTIFIER||LA134_1==INT||LA134_1==INTLITERAL||(LA134_1 >= LONG && LA134_1 <= LPAREN)||LA134_1==NEW||LA134_1==NULL||LA134_1==PLUS||LA134_1==PLUSPLUS||LA134_1==SHORT||(LA134_1 >= STRINGLITERAL && LA134_1 <= SUB)||(LA134_1 >= SUBSUB && LA134_1 <= SUPER)||LA134_1==THIS||LA134_1==TILDE||LA134_1==TRUE||LA134_1==VOID) ) {
                    alt134=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 134, 1, input);

                    throw nvae;

                }
            }
            else if ( (LA134_0==GT) ) {
                int LA134_2 = input.LA(2);

                if ( (LA134_2==EQ) ) {
                    alt134=2;
                }
                else if ( (LA134_2==BANG||LA134_2==BOOLEAN||LA134_2==BYTE||(LA134_2 >= CHAR && LA134_2 <= CHARLITERAL)||(LA134_2 >= DOUBLE && LA134_2 <= DOUBLELITERAL)||LA134_2==FALSE||(LA134_2 >= FLOAT && LA134_2 <= FLOATLITERAL)||LA134_2==IDENTIFIER||LA134_2==INT||LA134_2==INTLITERAL||(LA134_2 >= LONG && LA134_2 <= LPAREN)||LA134_2==NEW||LA134_2==NULL||LA134_2==PLUS||LA134_2==PLUSPLUS||LA134_2==SHORT||(LA134_2 >= STRINGLITERAL && LA134_2 <= SUB)||(LA134_2 >= SUBSUB && LA134_2 <= SUPER)||LA134_2==THIS||LA134_2==TILDE||LA134_2==TRUE||LA134_2==VOID) ) {
                    alt134=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 134, 2, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 134, 0, input);

                throw nvae;

            }
            switch (alt134) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1131:10: '<' '='
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal484=(Token)match(input,LT,FOLLOW_LT_in_relationalOp7548); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal484_tree = 
                    (Object)adaptor.create(char_literal484)
                    ;
                    adaptor.addChild(root_0, char_literal484_tree);
                    }

                    char_literal485=(Token)match(input,EQ,FOLLOW_EQ_in_relationalOp7550); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal485_tree = 
                    (Object)adaptor.create(char_literal485)
                    ;
                    adaptor.addChild(root_0, char_literal485_tree);
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1132:10: '>' '='
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal486=(Token)match(input,GT,FOLLOW_GT_in_relationalOp7561); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal486_tree = 
                    (Object)adaptor.create(char_literal486)
                    ;
                    adaptor.addChild(root_0, char_literal486_tree);
                    }

                    char_literal487=(Token)match(input,EQ,FOLLOW_EQ_in_relationalOp7563); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal487_tree = 
                    (Object)adaptor.create(char_literal487)
                    ;
                    adaptor.addChild(root_0, char_literal487_tree);
                    }

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1133:9: '<'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal488=(Token)match(input,LT,FOLLOW_LT_in_relationalOp7573); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal488_tree = 
                    (Object)adaptor.create(char_literal488)
                    ;
                    adaptor.addChild(root_0, char_literal488_tree);
                    }

                    }
                    break;
                case 4 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1134:9: '>'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal489=(Token)match(input,GT,FOLLOW_GT_in_relationalOp7583); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal489_tree = 
                    (Object)adaptor.create(char_literal489)
                    ;
                    adaptor.addChild(root_0, char_literal489_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 83, relationalOp_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "relationalOp"


    public static class shiftExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "shiftExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1137:1: shiftExpression : additiveExpression ( shiftOp additiveExpression )* ;
    public final JavaTreeParser.shiftExpression_return shiftExpression() throws RecognitionException {
        JavaTreeParser.shiftExpression_return retval = new JavaTreeParser.shiftExpression_return();
        retval.start = input.LT(1);

        int shiftExpression_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.additiveExpression_return additiveExpression490 =null;

        JavaTreeParser.shiftOp_return shiftOp491 =null;

        JavaTreeParser.additiveExpression_return additiveExpression492 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 84) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1138:5: ( additiveExpression ( shiftOp additiveExpression )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1138:9: additiveExpression ( shiftOp additiveExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_additiveExpression_in_shiftExpression7603);
            additiveExpression490=additiveExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, additiveExpression490.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1139:9: ( shiftOp additiveExpression )*
            loop135:
            do {
                int alt135=2;
                int LA135_0 = input.LA(1);

                if ( (LA135_0==LT) ) {
                    int LA135_1 = input.LA(2);

                    if ( (LA135_1==LT) ) {
                        int LA135_4 = input.LA(3);

                        if ( (LA135_4==BANG||LA135_4==BOOLEAN||LA135_4==BYTE||(LA135_4 >= CHAR && LA135_4 <= CHARLITERAL)||(LA135_4 >= DOUBLE && LA135_4 <= DOUBLELITERAL)||LA135_4==FALSE||(LA135_4 >= FLOAT && LA135_4 <= FLOATLITERAL)||LA135_4==IDENTIFIER||LA135_4==INT||LA135_4==INTLITERAL||(LA135_4 >= LONG && LA135_4 <= LPAREN)||LA135_4==NEW||LA135_4==NULL||LA135_4==PLUS||LA135_4==PLUSPLUS||LA135_4==SHORT||(LA135_4 >= STRINGLITERAL && LA135_4 <= SUB)||(LA135_4 >= SUBSUB && LA135_4 <= SUPER)||LA135_4==THIS||LA135_4==TILDE||LA135_4==TRUE||LA135_4==VOID) ) {
                            alt135=1;
                        }


                    }


                }
                else if ( (LA135_0==GT) ) {
                    int LA135_2 = input.LA(2);

                    if ( (LA135_2==GT) ) {
                        int LA135_5 = input.LA(3);

                        if ( (LA135_5==GT) ) {
                            int LA135_7 = input.LA(4);

                            if ( (LA135_7==BANG||LA135_7==BOOLEAN||LA135_7==BYTE||(LA135_7 >= CHAR && LA135_7 <= CHARLITERAL)||(LA135_7 >= DOUBLE && LA135_7 <= DOUBLELITERAL)||LA135_7==FALSE||(LA135_7 >= FLOAT && LA135_7 <= FLOATLITERAL)||LA135_7==IDENTIFIER||LA135_7==INT||LA135_7==INTLITERAL||(LA135_7 >= LONG && LA135_7 <= LPAREN)||LA135_7==NEW||LA135_7==NULL||LA135_7==PLUS||LA135_7==PLUSPLUS||LA135_7==SHORT||(LA135_7 >= STRINGLITERAL && LA135_7 <= SUB)||(LA135_7 >= SUBSUB && LA135_7 <= SUPER)||LA135_7==THIS||LA135_7==TILDE||LA135_7==TRUE||LA135_7==VOID) ) {
                                alt135=1;
                            }


                        }
                        else if ( (LA135_5==BANG||LA135_5==BOOLEAN||LA135_5==BYTE||(LA135_5 >= CHAR && LA135_5 <= CHARLITERAL)||(LA135_5 >= DOUBLE && LA135_5 <= DOUBLELITERAL)||LA135_5==FALSE||(LA135_5 >= FLOAT && LA135_5 <= FLOATLITERAL)||LA135_5==IDENTIFIER||LA135_5==INT||LA135_5==INTLITERAL||(LA135_5 >= LONG && LA135_5 <= LPAREN)||LA135_5==NEW||LA135_5==NULL||LA135_5==PLUS||LA135_5==PLUSPLUS||LA135_5==SHORT||(LA135_5 >= STRINGLITERAL && LA135_5 <= SUB)||(LA135_5 >= SUBSUB && LA135_5 <= SUPER)||LA135_5==THIS||LA135_5==TILDE||LA135_5==TRUE||LA135_5==VOID) ) {
                            alt135=1;
                        }


                    }


                }


                switch (alt135) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1139:10: shiftOp additiveExpression
            	    {
            	    pushFollow(FOLLOW_shiftOp_in_shiftExpression7614);
            	    shiftOp491=shiftOp();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, shiftOp491.getTree());

            	    pushFollow(FOLLOW_additiveExpression_in_shiftExpression7616);
            	    additiveExpression492=additiveExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, additiveExpression492.getTree());

            	    }
            	    break;

            	default :
            	    break loop135;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 84, shiftExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "shiftExpression"


    public static class shiftOp_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "shiftOp"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1144:1: shiftOp : ( '<' '<' | '>' '>' '>' | '>' '>' );
    public final JavaTreeParser.shiftOp_return shiftOp() throws RecognitionException {
        JavaTreeParser.shiftOp_return retval = new JavaTreeParser.shiftOp_return();
        retval.start = input.LT(1);

        int shiftOp_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal493=null;
        Token char_literal494=null;
        Token char_literal495=null;
        Token char_literal496=null;
        Token char_literal497=null;
        Token char_literal498=null;
        Token char_literal499=null;

        Object char_literal493_tree=null;
        Object char_literal494_tree=null;
        Object char_literal495_tree=null;
        Object char_literal496_tree=null;
        Object char_literal497_tree=null;
        Object char_literal498_tree=null;
        Object char_literal499_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 85) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1145:5: ( '<' '<' | '>' '>' '>' | '>' '>' )
            int alt136=3;
            int LA136_0 = input.LA(1);

            if ( (LA136_0==LT) ) {
                alt136=1;
            }
            else if ( (LA136_0==GT) ) {
                int LA136_2 = input.LA(2);

                if ( (LA136_2==GT) ) {
                    int LA136_3 = input.LA(3);

                    if ( (LA136_3==GT) ) {
                        alt136=2;
                    }
                    else if ( (LA136_3==BANG||LA136_3==BOOLEAN||LA136_3==BYTE||(LA136_3 >= CHAR && LA136_3 <= CHARLITERAL)||(LA136_3 >= DOUBLE && LA136_3 <= DOUBLELITERAL)||LA136_3==FALSE||(LA136_3 >= FLOAT && LA136_3 <= FLOATLITERAL)||LA136_3==IDENTIFIER||LA136_3==INT||LA136_3==INTLITERAL||(LA136_3 >= LONG && LA136_3 <= LPAREN)||LA136_3==NEW||LA136_3==NULL||LA136_3==PLUS||LA136_3==PLUSPLUS||LA136_3==SHORT||(LA136_3 >= STRINGLITERAL && LA136_3 <= SUB)||(LA136_3 >= SUBSUB && LA136_3 <= SUPER)||LA136_3==THIS||LA136_3==TILDE||LA136_3==TRUE||LA136_3==VOID) ) {
                        alt136=3;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return retval;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 136, 3, input);

                        throw nvae;

                    }
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 136, 2, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 136, 0, input);

                throw nvae;

            }
            switch (alt136) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1145:10: '<' '<'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal493=(Token)match(input,LT,FOLLOW_LT_in_shiftOp7649); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal493_tree = 
                    (Object)adaptor.create(char_literal493)
                    ;
                    adaptor.addChild(root_0, char_literal493_tree);
                    }

                    char_literal494=(Token)match(input,LT,FOLLOW_LT_in_shiftOp7651); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal494_tree = 
                    (Object)adaptor.create(char_literal494)
                    ;
                    adaptor.addChild(root_0, char_literal494_tree);
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1146:10: '>' '>' '>'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal495=(Token)match(input,GT,FOLLOW_GT_in_shiftOp7662); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal495_tree = 
                    (Object)adaptor.create(char_literal495)
                    ;
                    adaptor.addChild(root_0, char_literal495_tree);
                    }

                    char_literal496=(Token)match(input,GT,FOLLOW_GT_in_shiftOp7664); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal496_tree = 
                    (Object)adaptor.create(char_literal496)
                    ;
                    adaptor.addChild(root_0, char_literal496_tree);
                    }

                    char_literal497=(Token)match(input,GT,FOLLOW_GT_in_shiftOp7666); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal497_tree = 
                    (Object)adaptor.create(char_literal497)
                    ;
                    adaptor.addChild(root_0, char_literal497_tree);
                    }

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1147:10: '>' '>'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal498=(Token)match(input,GT,FOLLOW_GT_in_shiftOp7677); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal498_tree = 
                    (Object)adaptor.create(char_literal498)
                    ;
                    adaptor.addChild(root_0, char_literal498_tree);
                    }

                    char_literal499=(Token)match(input,GT,FOLLOW_GT_in_shiftOp7679); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal499_tree = 
                    (Object)adaptor.create(char_literal499)
                    ;
                    adaptor.addChild(root_0, char_literal499_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 85, shiftOp_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "shiftOp"


    public static class additiveExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "additiveExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1151:1: additiveExpression : multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* ;
    public final JavaTreeParser.additiveExpression_return additiveExpression() throws RecognitionException {
        JavaTreeParser.additiveExpression_return retval = new JavaTreeParser.additiveExpression_return();
        retval.start = input.LT(1);

        int additiveExpression_StartIndex = input.index();

        Object root_0 = null;

        Token set501=null;
        JavaTreeParser.multiplicativeExpression_return multiplicativeExpression500 =null;

        JavaTreeParser.multiplicativeExpression_return multiplicativeExpression502 =null;


        Object set501_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 86) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1152:5: ( multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1152:9: multiplicativeExpression ( ( '+' | '-' ) multiplicativeExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression7700);
            multiplicativeExpression500=multiplicativeExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, multiplicativeExpression500.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1153:9: ( ( '+' | '-' ) multiplicativeExpression )*
            loop137:
            do {
                int alt137=2;
                int LA137_0 = input.LA(1);

                if ( (LA137_0==PLUS||LA137_0==SUB) ) {
                    alt137=1;
                }


                switch (alt137) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1154:13: ( '+' | '-' ) multiplicativeExpression
            	    {
            	    set501=(Token)input.LT(1);

            	    if ( input.LA(1)==PLUS||input.LA(1)==SUB ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, 
            	        (Object)adaptor.create(set501)
            	        );
            	        state.errorRecovery=false;
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression7777);
            	    multiplicativeExpression502=multiplicativeExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, multiplicativeExpression502.getTree());

            	    }
            	    break;

            	default :
            	    break loop137;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 86, additiveExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "additiveExpression"


    public static class multiplicativeExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "multiplicativeExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1161:1: multiplicativeExpression : unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* ;
    public final JavaTreeParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException {
        JavaTreeParser.multiplicativeExpression_return retval = new JavaTreeParser.multiplicativeExpression_return();
        retval.start = input.LT(1);

        int multiplicativeExpression_StartIndex = input.index();

        Object root_0 = null;

        Token set504=null;
        JavaTreeParser.unaryExpression_return unaryExpression503 =null;

        JavaTreeParser.unaryExpression_return unaryExpression505 =null;


        Object set504_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 87) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1162:5: ( unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )* )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1163:9: unaryExpression ( ( '*' | '/' | '%' ) unaryExpression )*
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression7815);
            unaryExpression503=unaryExpression();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression503.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1164:9: ( ( '*' | '/' | '%' ) unaryExpression )*
            loop138:
            do {
                int alt138=2;
                int LA138_0 = input.LA(1);

                if ( (LA138_0==PERCENT||LA138_0==SLASH||LA138_0==STAR) ) {
                    alt138=1;
                }


                switch (alt138) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1165:13: ( '*' | '/' | '%' ) unaryExpression
            	    {
            	    set504=(Token)input.LT(1);

            	    if ( input.LA(1)==PERCENT||input.LA(1)==SLASH||input.LA(1)==STAR ) {
            	        input.consume();
            	        if ( state.backtracking==0 ) adaptor.addChild(root_0, 
            	        (Object)adaptor.create(set504)
            	        );
            	        state.errorRecovery=false;
            	        state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return retval;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression7910);
            	    unaryExpression505=unaryExpression();

            	    state._fsp--;
            	    if (state.failed) return retval;
            	    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression505.getTree());

            	    }
            	    break;

            	default :
            	    break loop138;
                }
            } while (true);


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 87, multiplicativeExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "multiplicativeExpression"


    public static class unaryExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "unaryExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1177:1: unaryExpression : ( '+' unaryExpression | '-' unaryExpression | '++' unaryExpression | '--' unaryExpression | unaryExpressionNotPlusMinus );
    public final JavaTreeParser.unaryExpression_return unaryExpression() throws RecognitionException {
        JavaTreeParser.unaryExpression_return retval = new JavaTreeParser.unaryExpression_return();
        retval.start = input.LT(1);

        int unaryExpression_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal506=null;
        Token char_literal508=null;
        Token string_literal510=null;
        Token string_literal512=null;
        JavaTreeParser.unaryExpression_return unaryExpression507 =null;

        JavaTreeParser.unaryExpression_return unaryExpression509 =null;

        JavaTreeParser.unaryExpression_return unaryExpression511 =null;

        JavaTreeParser.unaryExpression_return unaryExpression513 =null;

        JavaTreeParser.unaryExpressionNotPlusMinus_return unaryExpressionNotPlusMinus514 =null;


        Object char_literal506_tree=null;
        Object char_literal508_tree=null;
        Object string_literal510_tree=null;
        Object string_literal512_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 88) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1178:5: ( '+' unaryExpression | '-' unaryExpression | '++' unaryExpression | '--' unaryExpression | unaryExpressionNotPlusMinus )
            int alt139=5;
            switch ( input.LA(1) ) {
            case PLUS:
                {
                alt139=1;
                }
                break;
            case SUB:
                {
                alt139=2;
                }
                break;
            case PLUSPLUS:
                {
                alt139=3;
                }
                break;
            case SUBSUB:
                {
                alt139=4;
                }
                break;
            case BANG:
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CHARLITERAL:
            case DOUBLE:
            case DOUBLELITERAL:
            case FALSE:
            case FLOAT:
            case FLOATLITERAL:
            case IDENTIFIER:
            case INT:
            case INTLITERAL:
            case LONG:
            case LONGLITERAL:
            case LPAREN:
            case NEW:
            case NULL:
            case SHORT:
            case STRINGLITERAL:
            case SUPER:
            case THIS:
            case TILDE:
            case TRUE:
            case VOID:
                {
                alt139=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 139, 0, input);

                throw nvae;

            }

            switch (alt139) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1178:9: '+' unaryExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal506=(Token)match(input,PLUS,FOLLOW_PLUS_in_unaryExpression7943); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal506_tree = 
                    (Object)adaptor.create(char_literal506)
                    ;
                    adaptor.addChild(root_0, char_literal506_tree);
                    }

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression7946);
                    unaryExpression507=unaryExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression507.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1179:9: '-' unaryExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal508=(Token)match(input,SUB,FOLLOW_SUB_in_unaryExpression7956); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal508_tree = 
                    (Object)adaptor.create(char_literal508)
                    ;
                    adaptor.addChild(root_0, char_literal508_tree);
                    }

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression7958);
                    unaryExpression509=unaryExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression509.getTree());

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1180:9: '++' unaryExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal510=(Token)match(input,PLUSPLUS,FOLLOW_PLUSPLUS_in_unaryExpression7968); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal510_tree = 
                    (Object)adaptor.create(string_literal510)
                    ;
                    adaptor.addChild(root_0, string_literal510_tree);
                    }

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression7970);
                    unaryExpression511=unaryExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression511.getTree());

                    }
                    break;
                case 4 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1181:9: '--' unaryExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal512=(Token)match(input,SUBSUB,FOLLOW_SUBSUB_in_unaryExpression7980); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal512_tree = 
                    (Object)adaptor.create(string_literal512)
                    ;
                    adaptor.addChild(root_0, string_literal512_tree);
                    }

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression7982);
                    unaryExpression513=unaryExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression513.getTree());

                    }
                    break;
                case 5 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1182:9: unaryExpressionNotPlusMinus
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression7992);
                    unaryExpressionNotPlusMinus514=unaryExpressionNotPlusMinus();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpressionNotPlusMinus514.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 88, unaryExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "unaryExpression"


    public static class unaryExpressionNotPlusMinus_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "unaryExpressionNotPlusMinus"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1185:1: unaryExpressionNotPlusMinus : ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? );
    public final JavaTreeParser.unaryExpressionNotPlusMinus_return unaryExpressionNotPlusMinus() throws RecognitionException {
        JavaTreeParser.unaryExpressionNotPlusMinus_return retval = new JavaTreeParser.unaryExpressionNotPlusMinus_return();
        retval.start = input.LT(1);

        int unaryExpressionNotPlusMinus_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal515=null;
        Token char_literal517=null;
        Token set522=null;
        JavaTreeParser.unaryExpression_return unaryExpression516 =null;

        JavaTreeParser.unaryExpression_return unaryExpression518 =null;

        JavaTreeParser.castExpression_return castExpression519 =null;

        JavaTreeParser.primary_return primary520 =null;

        JavaTreeParser.selector_return selector521 =null;


        Object char_literal515_tree=null;
        Object char_literal517_tree=null;
        Object set522_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 89) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1186:5: ( '~' unaryExpression | '!' unaryExpression | castExpression | primary ( selector )* ( '++' | '--' )? )
            int alt142=4;
            switch ( input.LA(1) ) {
            case TILDE:
                {
                alt142=1;
                }
                break;
            case BANG:
                {
                alt142=2;
                }
                break;
            case LPAREN:
                {
                int LA142_3 = input.LA(2);

                if ( (synpred219_JavaTree()) ) {
                    alt142=3;
                }
                else if ( (true) ) {
                    alt142=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 142, 3, input);

                    throw nvae;

                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case CHARLITERAL:
            case DOUBLE:
            case DOUBLELITERAL:
            case FALSE:
            case FLOAT:
            case FLOATLITERAL:
            case IDENTIFIER:
            case INT:
            case INTLITERAL:
            case LONG:
            case LONGLITERAL:
            case NEW:
            case NULL:
            case SHORT:
            case STRINGLITERAL:
            case SUPER:
            case THIS:
            case TRUE:
            case VOID:
                {
                alt142=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 142, 0, input);

                throw nvae;

            }

            switch (alt142) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1186:9: '~' unaryExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal515=(Token)match(input,TILDE,FOLLOW_TILDE_in_unaryExpressionNotPlusMinus8012); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal515_tree = 
                    (Object)adaptor.create(char_literal515)
                    ;
                    adaptor.addChild(root_0, char_literal515_tree);
                    }

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus8014);
                    unaryExpression516=unaryExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression516.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1187:9: '!' unaryExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal517=(Token)match(input,BANG,FOLLOW_BANG_in_unaryExpressionNotPlusMinus8024); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal517_tree = 
                    (Object)adaptor.create(char_literal517)
                    ;
                    adaptor.addChild(root_0, char_literal517_tree);
                    }

                    pushFollow(FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus8026);
                    unaryExpression518=unaryExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression518.getTree());

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1188:9: castExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_castExpression_in_unaryExpressionNotPlusMinus8036);
                    castExpression519=castExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, castExpression519.getTree());

                    }
                    break;
                case 4 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1189:9: primary ( selector )* ( '++' | '--' )?
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_primary_in_unaryExpressionNotPlusMinus8046);
                    primary520=primary();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, primary520.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1190:9: ( selector )*
                    loop140:
                    do {
                        int alt140=2;
                        int LA140_0 = input.LA(1);

                        if ( (LA140_0==DOT||LA140_0==LBRACKET) ) {
                            alt140=1;
                        }


                        switch (alt140) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1190:10: selector
                    	    {
                    	    pushFollow(FOLLOW_selector_in_unaryExpressionNotPlusMinus8057);
                    	    selector521=selector();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, selector521.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop140;
                        }
                    } while (true);


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1192:9: ( '++' | '--' )?
                    int alt141=2;
                    int LA141_0 = input.LA(1);

                    if ( (LA141_0==PLUSPLUS||LA141_0==SUBSUB) ) {
                        alt141=1;
                    }
                    switch (alt141) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:
                            {
                            set522=(Token)input.LT(1);

                            if ( input.LA(1)==PLUSPLUS||input.LA(1)==SUBSUB ) {
                                input.consume();
                                if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                                (Object)adaptor.create(set522)
                                );
                                state.errorRecovery=false;
                                state.failed=false;
                            }
                            else {
                                if (state.backtracking>0) {state.failed=true; return retval;}
                                MismatchedSetException mse = new MismatchedSetException(null,input);
                                throw mse;
                            }


                            }
                            break;

                    }


                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 89, unaryExpressionNotPlusMinus_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "unaryExpressionNotPlusMinus"


    public static class castExpression_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "castExpression"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1197:1: castExpression : ( '(' primitiveType ')' unaryExpression | '(' type ')' unaryExpressionNotPlusMinus );
    public final JavaTreeParser.castExpression_return castExpression() throws RecognitionException {
        JavaTreeParser.castExpression_return retval = new JavaTreeParser.castExpression_return();
        retval.start = input.LT(1);

        int castExpression_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal523=null;
        Token char_literal525=null;
        Token char_literal527=null;
        Token char_literal529=null;
        JavaTreeParser.primitiveType_return primitiveType524 =null;

        JavaTreeParser.unaryExpression_return unaryExpression526 =null;

        JavaTreeParser.type_return type528 =null;

        JavaTreeParser.unaryExpressionNotPlusMinus_return unaryExpressionNotPlusMinus530 =null;


        Object char_literal523_tree=null;
        Object char_literal525_tree=null;
        Object char_literal527_tree=null;
        Object char_literal529_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 90) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1198:5: ( '(' primitiveType ')' unaryExpression | '(' type ')' unaryExpressionNotPlusMinus )
            int alt143=2;
            int LA143_0 = input.LA(1);

            if ( (LA143_0==LPAREN) ) {
                int LA143_1 = input.LA(2);

                if ( (synpred223_JavaTree()) ) {
                    alt143=1;
                }
                else if ( (true) ) {
                    alt143=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 143, 1, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 143, 0, input);

                throw nvae;

            }
            switch (alt143) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1198:9: '(' primitiveType ')' unaryExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal523=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_castExpression8127); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal523_tree = 
                    (Object)adaptor.create(char_literal523)
                    ;
                    adaptor.addChild(root_0, char_literal523_tree);
                    }

                    pushFollow(FOLLOW_primitiveType_in_castExpression8129);
                    primitiveType524=primitiveType();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, primitiveType524.getTree());

                    char_literal525=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_castExpression8131); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal525_tree = 
                    (Object)adaptor.create(char_literal525)
                    ;
                    adaptor.addChild(root_0, char_literal525_tree);
                    }

                    pushFollow(FOLLOW_unaryExpression_in_castExpression8133);
                    unaryExpression526=unaryExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpression526.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1199:9: '(' type ')' unaryExpressionNotPlusMinus
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal527=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_castExpression8143); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal527_tree = 
                    (Object)adaptor.create(char_literal527)
                    ;
                    adaptor.addChild(root_0, char_literal527_tree);
                    }

                    pushFollow(FOLLOW_type_in_castExpression8145);
                    type528=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, type528.getTree());

                    char_literal529=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_castExpression8147); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal529_tree = 
                    (Object)adaptor.create(char_literal529)
                    ;
                    adaptor.addChild(root_0, char_literal529_tree);
                    }

                    pushFollow(FOLLOW_unaryExpressionNotPlusMinus_in_castExpression8149);
                    unaryExpressionNotPlusMinus530=unaryExpressionNotPlusMinus();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, unaryExpressionNotPlusMinus530.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 90, castExpression_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "castExpression"


    public static class primary_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "primary"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1205:1: primary : ( parExpression | 'this' ( '.' IDENTIFIER )* ( identifierSuffix )? | IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )? | 'super' superSuffix | literal | creator | primitiveType ( '[' ']' )* '.' 'class' | 'void' '.' 'class' );
    public final JavaTreeParser.primary_return primary() throws RecognitionException {
        JavaTreeParser.primary_return retval = new JavaTreeParser.primary_return();
        retval.start = input.LT(1);

        int primary_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal532=null;
        Token char_literal533=null;
        Token IDENTIFIER534=null;
        Token IDENTIFIER536=null;
        Token char_literal537=null;
        Token IDENTIFIER538=null;
        Token string_literal540=null;
        Token char_literal545=null;
        Token char_literal546=null;
        Token char_literal547=null;
        Token string_literal548=null;
        Token string_literal549=null;
        Token char_literal550=null;
        Token string_literal551=null;
        JavaTreeParser.parExpression_return parExpression531 =null;

        JavaTreeParser.identifierSuffix_return identifierSuffix535 =null;

        JavaTreeParser.identifierSuffix_return identifierSuffix539 =null;

        JavaTreeParser.superSuffix_return superSuffix541 =null;

        JavaTreeParser.literal_return literal542 =null;

        JavaTreeParser.creator_return creator543 =null;

        JavaTreeParser.primitiveType_return primitiveType544 =null;


        Object string_literal532_tree=null;
        Object char_literal533_tree=null;
        Object IDENTIFIER534_tree=null;
        Object IDENTIFIER536_tree=null;
        Object char_literal537_tree=null;
        Object IDENTIFIER538_tree=null;
        Object string_literal540_tree=null;
        Object char_literal545_tree=null;
        Object char_literal546_tree=null;
        Object char_literal547_tree=null;
        Object string_literal548_tree=null;
        Object string_literal549_tree=null;
        Object char_literal550_tree=null;
        Object string_literal551_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 91) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1206:5: ( parExpression | 'this' ( '.' IDENTIFIER )* ( identifierSuffix )? | IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )? | 'super' superSuffix | literal | creator | primitiveType ( '[' ']' )* '.' 'class' | 'void' '.' 'class' )
            int alt149=8;
            switch ( input.LA(1) ) {
            case LPAREN:
                {
                alt149=1;
                }
                break;
            case THIS:
                {
                alt149=2;
                }
                break;
            case IDENTIFIER:
                {
                alt149=3;
                }
                break;
            case SUPER:
                {
                alt149=4;
                }
                break;
            case CHARLITERAL:
            case DOUBLELITERAL:
            case FALSE:
            case FLOATLITERAL:
            case INTLITERAL:
            case LONGLITERAL:
            case NULL:
            case STRINGLITERAL:
            case TRUE:
                {
                alt149=5;
                }
                break;
            case NEW:
                {
                alt149=6;
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case INT:
            case LONG:
            case SHORT:
                {
                alt149=7;
                }
                break;
            case VOID:
                {
                alt149=8;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 149, 0, input);

                throw nvae;

            }

            switch (alt149) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1206:9: parExpression
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_parExpression_in_primary8171);
                    parExpression531=parExpression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, parExpression531.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1207:9: 'this' ( '.' IDENTIFIER )* ( identifierSuffix )?
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal532=(Token)match(input,THIS,FOLLOW_THIS_in_primary8193); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal532_tree = 
                    (Object)adaptor.create(string_literal532)
                    ;
                    adaptor.addChild(root_0, string_literal532_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1208:9: ( '.' IDENTIFIER )*
                    loop144:
                    do {
                        int alt144=2;
                        int LA144_0 = input.LA(1);

                        if ( (LA144_0==DOT) ) {
                            int LA144_2 = input.LA(2);

                            if ( (LA144_2==IDENTIFIER) ) {
                                int LA144_3 = input.LA(3);

                                if ( (synpred225_JavaTree()) ) {
                                    alt144=1;
                                }


                            }


                        }


                        switch (alt144) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1208:10: '.' IDENTIFIER
                    	    {
                    	    char_literal533=(Token)match(input,DOT,FOLLOW_DOT_in_primary8204); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal533_tree = 
                    	    (Object)adaptor.create(char_literal533)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal533_tree);
                    	    }

                    	    IDENTIFIER534=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary8206); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    IDENTIFIER534_tree = 
                    	    (Object)adaptor.create(IDENTIFIER534)
                    	    ;
                    	    adaptor.addChild(root_0, IDENTIFIER534_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    break loop144;
                        }
                    } while (true);


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1210:9: ( identifierSuffix )?
                    int alt145=2;
                    switch ( input.LA(1) ) {
                        case LBRACKET:
                            {
                            int LA145_1 = input.LA(2);

                            if ( (synpred226_JavaTree()) ) {
                                alt145=1;
                            }
                            }
                            break;
                        case LPAREN:
                            {
                            alt145=1;
                            }
                            break;
                        case DOT:
                            {
                            int LA145_3 = input.LA(2);

                            if ( (synpred226_JavaTree()) ) {
                                alt145=1;
                            }
                            }
                            break;
                    }

                    switch (alt145) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1210:10: identifierSuffix
                            {
                            pushFollow(FOLLOW_identifierSuffix_in_primary8228);
                            identifierSuffix535=identifierSuffix();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, identifierSuffix535.getTree());

                            }
                            break;

                    }


                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1212:9: IDENTIFIER ( '.' IDENTIFIER )* ( identifierSuffix )?
                    {
                    root_0 = (Object)adaptor.nil();


                    IDENTIFIER536=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary8249); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER536_tree = 
                    (Object)adaptor.create(IDENTIFIER536)
                    ;
                    adaptor.addChild(root_0, IDENTIFIER536_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1213:9: ( '.' IDENTIFIER )*
                    loop146:
                    do {
                        int alt146=2;
                        int LA146_0 = input.LA(1);

                        if ( (LA146_0==DOT) ) {
                            int LA146_2 = input.LA(2);

                            if ( (LA146_2==IDENTIFIER) ) {
                                int LA146_3 = input.LA(3);

                                if ( (synpred228_JavaTree()) ) {
                                    alt146=1;
                                }


                            }


                        }


                        switch (alt146) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1213:10: '.' IDENTIFIER
                    	    {
                    	    char_literal537=(Token)match(input,DOT,FOLLOW_DOT_in_primary8260); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal537_tree = 
                    	    (Object)adaptor.create(char_literal537)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal537_tree);
                    	    }

                    	    IDENTIFIER538=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primary8262); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    IDENTIFIER538_tree = 
                    	    (Object)adaptor.create(IDENTIFIER538)
                    	    ;
                    	    adaptor.addChild(root_0, IDENTIFIER538_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    break loop146;
                        }
                    } while (true);


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1215:9: ( identifierSuffix )?
                    int alt147=2;
                    switch ( input.LA(1) ) {
                        case LBRACKET:
                            {
                            int LA147_1 = input.LA(2);

                            if ( (synpred229_JavaTree()) ) {
                                alt147=1;
                            }
                            }
                            break;
                        case LPAREN:
                            {
                            alt147=1;
                            }
                            break;
                        case DOT:
                            {
                            int LA147_3 = input.LA(2);

                            if ( (synpred229_JavaTree()) ) {
                                alt147=1;
                            }
                            }
                            break;
                    }

                    switch (alt147) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1215:10: identifierSuffix
                            {
                            pushFollow(FOLLOW_identifierSuffix_in_primary8284);
                            identifierSuffix539=identifierSuffix();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, identifierSuffix539.getTree());

                            }
                            break;

                    }


                    }
                    break;
                case 4 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1217:9: 'super' superSuffix
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal540=(Token)match(input,SUPER,FOLLOW_SUPER_in_primary8305); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal540_tree = 
                    (Object)adaptor.create(string_literal540)
                    ;
                    adaptor.addChild(root_0, string_literal540_tree);
                    }

                    pushFollow(FOLLOW_superSuffix_in_primary8315);
                    superSuffix541=superSuffix();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, superSuffix541.getTree());

                    }
                    break;
                case 5 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1219:9: literal
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_literal_in_primary8325);
                    literal542=literal();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, literal542.getTree());

                    }
                    break;
                case 6 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1220:9: creator
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_creator_in_primary8335);
                    creator543=creator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, creator543.getTree());

                    }
                    break;
                case 7 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1221:9: primitiveType ( '[' ']' )* '.' 'class'
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_primitiveType_in_primary8345);
                    primitiveType544=primitiveType();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, primitiveType544.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1222:9: ( '[' ']' )*
                    loop148:
                    do {
                        int alt148=2;
                        int LA148_0 = input.LA(1);

                        if ( (LA148_0==LBRACKET) ) {
                            alt148=1;
                        }


                        switch (alt148) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1222:10: '[' ']'
                    	    {
                    	    char_literal545=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_primary8356); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal545_tree = 
                    	    (Object)adaptor.create(char_literal545)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal545_tree);
                    	    }

                    	    char_literal546=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_primary8358); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal546_tree = 
                    	    (Object)adaptor.create(char_literal546)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal546_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    break loop148;
                        }
                    } while (true);


                    char_literal547=(Token)match(input,DOT,FOLLOW_DOT_in_primary8379); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal547_tree = 
                    (Object)adaptor.create(char_literal547)
                    ;
                    adaptor.addChild(root_0, char_literal547_tree);
                    }

                    string_literal548=(Token)match(input,CLASS,FOLLOW_CLASS_in_primary8381); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal548_tree = 
                    (Object)adaptor.create(string_literal548)
                    ;
                    adaptor.addChild(root_0, string_literal548_tree);
                    }

                    }
                    break;
                case 8 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1225:9: 'void' '.' 'class'
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal549=(Token)match(input,VOID,FOLLOW_VOID_in_primary8391); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal549_tree = 
                    (Object)adaptor.create(string_literal549)
                    ;
                    adaptor.addChild(root_0, string_literal549_tree);
                    }

                    char_literal550=(Token)match(input,DOT,FOLLOW_DOT_in_primary8393); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal550_tree = 
                    (Object)adaptor.create(char_literal550)
                    ;
                    adaptor.addChild(root_0, char_literal550_tree);
                    }

                    string_literal551=(Token)match(input,CLASS,FOLLOW_CLASS_in_primary8395); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal551_tree = 
                    (Object)adaptor.create(string_literal551)
                    ;
                    adaptor.addChild(root_0, string_literal551_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 91, primary_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "primary"


    public static class superSuffix_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "superSuffix"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1229:1: superSuffix : ( arguments | '.' ( typeArguments )? IDENTIFIER ( arguments )? );
    public final JavaTreeParser.superSuffix_return superSuffix() throws RecognitionException {
        JavaTreeParser.superSuffix_return retval = new JavaTreeParser.superSuffix_return();
        retval.start = input.LT(1);

        int superSuffix_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal553=null;
        Token IDENTIFIER555=null;
        JavaTreeParser.arguments_return arguments552 =null;

        JavaTreeParser.typeArguments_return typeArguments554 =null;

        JavaTreeParser.arguments_return arguments556 =null;


        Object char_literal553_tree=null;
        Object IDENTIFIER555_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 92) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1230:5: ( arguments | '.' ( typeArguments )? IDENTIFIER ( arguments )? )
            int alt152=2;
            int LA152_0 = input.LA(1);

            if ( (LA152_0==LPAREN) ) {
                alt152=1;
            }
            else if ( (LA152_0==DOT) ) {
                alt152=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 152, 0, input);

                throw nvae;

            }
            switch (alt152) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1230:9: arguments
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_arguments_in_superSuffix8421);
                    arguments552=arguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, arguments552.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1231:9: '.' ( typeArguments )? IDENTIFIER ( arguments )?
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal553=(Token)match(input,DOT,FOLLOW_DOT_in_superSuffix8431); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal553_tree = 
                    (Object)adaptor.create(char_literal553)
                    ;
                    adaptor.addChild(root_0, char_literal553_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1231:13: ( typeArguments )?
                    int alt150=2;
                    int LA150_0 = input.LA(1);

                    if ( (LA150_0==LT) ) {
                        alt150=1;
                    }
                    switch (alt150) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1231:14: typeArguments
                            {
                            pushFollow(FOLLOW_typeArguments_in_superSuffix8434);
                            typeArguments554=typeArguments();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, typeArguments554.getTree());

                            }
                            break;

                    }


                    IDENTIFIER555=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_superSuffix8455); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER555_tree = 
                    (Object)adaptor.create(IDENTIFIER555)
                    ;
                    adaptor.addChild(root_0, IDENTIFIER555_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1234:9: ( arguments )?
                    int alt151=2;
                    int LA151_0 = input.LA(1);

                    if ( (LA151_0==LPAREN) ) {
                        alt151=1;
                    }
                    switch (alt151) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1234:10: arguments
                            {
                            pushFollow(FOLLOW_arguments_in_superSuffix8466);
                            arguments556=arguments();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, arguments556.getTree());

                            }
                            break;

                    }


                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 92, superSuffix_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "superSuffix"


    public static class identifierSuffix_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "identifierSuffix"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1239:1: identifierSuffix : ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator );
    public final JavaTreeParser.identifierSuffix_return identifierSuffix() throws RecognitionException {
        JavaTreeParser.identifierSuffix_return retval = new JavaTreeParser.identifierSuffix_return();
        retval.start = input.LT(1);

        int identifierSuffix_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal557=null;
        Token char_literal558=null;
        Token char_literal559=null;
        Token string_literal560=null;
        Token char_literal561=null;
        Token char_literal563=null;
        Token char_literal565=null;
        Token string_literal566=null;
        Token char_literal567=null;
        Token IDENTIFIER569=null;
        Token char_literal571=null;
        Token string_literal572=null;
        Token char_literal573=null;
        Token string_literal574=null;
        JavaTreeParser.expression_return expression562 =null;

        JavaTreeParser.arguments_return arguments564 =null;

        JavaTreeParser.nonWildcardTypeArguments_return nonWildcardTypeArguments568 =null;

        JavaTreeParser.arguments_return arguments570 =null;

        JavaTreeParser.arguments_return arguments575 =null;

        JavaTreeParser.innerCreator_return innerCreator576 =null;


        Object char_literal557_tree=null;
        Object char_literal558_tree=null;
        Object char_literal559_tree=null;
        Object string_literal560_tree=null;
        Object char_literal561_tree=null;
        Object char_literal563_tree=null;
        Object char_literal565_tree=null;
        Object string_literal566_tree=null;
        Object char_literal567_tree=null;
        Object IDENTIFIER569_tree=null;
        Object char_literal571_tree=null;
        Object string_literal572_tree=null;
        Object char_literal573_tree=null;
        Object string_literal574_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 93) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1240:5: ( ( '[' ']' )+ '.' 'class' | ( '[' expression ']' )+ | arguments | '.' 'class' | '.' nonWildcardTypeArguments IDENTIFIER arguments | '.' 'this' | '.' 'super' arguments | innerCreator )
            int alt155=8;
            switch ( input.LA(1) ) {
            case LBRACKET:
                {
                int LA155_1 = input.LA(2);

                if ( (LA155_1==RBRACKET) ) {
                    alt155=1;
                }
                else if ( (LA155_1==BANG||LA155_1==BOOLEAN||LA155_1==BYTE||(LA155_1 >= CHAR && LA155_1 <= CHARLITERAL)||(LA155_1 >= DOUBLE && LA155_1 <= DOUBLELITERAL)||LA155_1==FALSE||(LA155_1 >= FLOAT && LA155_1 <= FLOATLITERAL)||LA155_1==IDENTIFIER||LA155_1==INT||LA155_1==INTLITERAL||(LA155_1 >= LONG && LA155_1 <= LPAREN)||LA155_1==NEW||LA155_1==NULL||LA155_1==PLUS||LA155_1==PLUSPLUS||LA155_1==SHORT||(LA155_1 >= STRINGLITERAL && LA155_1 <= SUB)||(LA155_1 >= SUBSUB && LA155_1 <= SUPER)||LA155_1==THIS||LA155_1==TILDE||LA155_1==TRUE||LA155_1==VOID) ) {
                    alt155=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 155, 1, input);

                    throw nvae;

                }
                }
                break;
            case LPAREN:
                {
                alt155=3;
                }
                break;
            case DOT:
                {
                switch ( input.LA(2) ) {
                case CLASS:
                    {
                    alt155=4;
                    }
                    break;
                case THIS:
                    {
                    alt155=6;
                    }
                    break;
                case SUPER:
                    {
                    alt155=7;
                    }
                    break;
                case NEW:
                    {
                    alt155=8;
                    }
                    break;
                case LT:
                    {
                    alt155=5;
                    }
                    break;
                default:
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 155, 3, input);

                    throw nvae;

                }

                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 155, 0, input);

                throw nvae;

            }

            switch (alt155) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1240:9: ( '[' ']' )+ '.' 'class'
                    {
                    root_0 = (Object)adaptor.nil();


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1240:9: ( '[' ']' )+
                    int cnt153=0;
                    loop153:
                    do {
                        int alt153=2;
                        int LA153_0 = input.LA(1);

                        if ( (LA153_0==LBRACKET) ) {
                            alt153=1;
                        }


                        switch (alt153) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1240:10: '[' ']'
                    	    {
                    	    char_literal557=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_identifierSuffix8499); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal557_tree = 
                    	    (Object)adaptor.create(char_literal557)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal557_tree);
                    	    }

                    	    char_literal558=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_identifierSuffix8501); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal558_tree = 
                    	    (Object)adaptor.create(char_literal558)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal558_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt153 >= 1 ) break loop153;
                    	    if (state.backtracking>0) {state.failed=true; return retval;}
                                EarlyExitException eee =
                                    new EarlyExitException(153, input);
                                throw eee;
                        }
                        cnt153++;
                    } while (true);


                    char_literal559=(Token)match(input,DOT,FOLLOW_DOT_in_identifierSuffix8522); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal559_tree = 
                    (Object)adaptor.create(char_literal559)
                    ;
                    adaptor.addChild(root_0, char_literal559_tree);
                    }

                    string_literal560=(Token)match(input,CLASS,FOLLOW_CLASS_in_identifierSuffix8524); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal560_tree = 
                    (Object)adaptor.create(string_literal560)
                    ;
                    adaptor.addChild(root_0, string_literal560_tree);
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1243:9: ( '[' expression ']' )+
                    {
                    root_0 = (Object)adaptor.nil();


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1243:9: ( '[' expression ']' )+
                    int cnt154=0;
                    loop154:
                    do {
                        int alt154=2;
                        int LA154_0 = input.LA(1);

                        if ( (LA154_0==LBRACKET) ) {
                            int LA154_2 = input.LA(2);

                            if ( (synpred241_JavaTree()) ) {
                                alt154=1;
                            }


                        }


                        switch (alt154) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1243:10: '[' expression ']'
                    	    {
                    	    char_literal561=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_identifierSuffix8535); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal561_tree = 
                    	    (Object)adaptor.create(char_literal561)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal561_tree);
                    	    }

                    	    pushFollow(FOLLOW_expression_in_identifierSuffix8537);
                    	    expression562=expression();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression562.getTree());

                    	    char_literal563=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_identifierSuffix8539); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal563_tree = 
                    	    (Object)adaptor.create(char_literal563)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal563_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    if ( cnt154 >= 1 ) break loop154;
                    	    if (state.backtracking>0) {state.failed=true; return retval;}
                                EarlyExitException eee =
                                    new EarlyExitException(154, input);
                                throw eee;
                        }
                        cnt154++;
                    } while (true);


                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1245:9: arguments
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_arguments_in_identifierSuffix8560);
                    arguments564=arguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, arguments564.getTree());

                    }
                    break;
                case 4 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1246:9: '.' 'class'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal565=(Token)match(input,DOT,FOLLOW_DOT_in_identifierSuffix8570); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal565_tree = 
                    (Object)adaptor.create(char_literal565)
                    ;
                    adaptor.addChild(root_0, char_literal565_tree);
                    }

                    string_literal566=(Token)match(input,CLASS,FOLLOW_CLASS_in_identifierSuffix8572); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal566_tree = 
                    (Object)adaptor.create(string_literal566)
                    ;
                    adaptor.addChild(root_0, string_literal566_tree);
                    }

                    }
                    break;
                case 5 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1247:9: '.' nonWildcardTypeArguments IDENTIFIER arguments
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal567=(Token)match(input,DOT,FOLLOW_DOT_in_identifierSuffix8582); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal567_tree = 
                    (Object)adaptor.create(char_literal567)
                    ;
                    adaptor.addChild(root_0, char_literal567_tree);
                    }

                    pushFollow(FOLLOW_nonWildcardTypeArguments_in_identifierSuffix8584);
                    nonWildcardTypeArguments568=nonWildcardTypeArguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, nonWildcardTypeArguments568.getTree());

                    IDENTIFIER569=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_identifierSuffix8586); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER569_tree = 
                    (Object)adaptor.create(IDENTIFIER569)
                    ;
                    adaptor.addChild(root_0, IDENTIFIER569_tree);
                    }

                    pushFollow(FOLLOW_arguments_in_identifierSuffix8588);
                    arguments570=arguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, arguments570.getTree());

                    }
                    break;
                case 6 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1248:9: '.' 'this'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal571=(Token)match(input,DOT,FOLLOW_DOT_in_identifierSuffix8598); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal571_tree = 
                    (Object)adaptor.create(char_literal571)
                    ;
                    adaptor.addChild(root_0, char_literal571_tree);
                    }

                    string_literal572=(Token)match(input,THIS,FOLLOW_THIS_in_identifierSuffix8600); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal572_tree = 
                    (Object)adaptor.create(string_literal572)
                    ;
                    adaptor.addChild(root_0, string_literal572_tree);
                    }

                    }
                    break;
                case 7 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1249:9: '.' 'super' arguments
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal573=(Token)match(input,DOT,FOLLOW_DOT_in_identifierSuffix8610); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal573_tree = 
                    (Object)adaptor.create(char_literal573)
                    ;
                    adaptor.addChild(root_0, char_literal573_tree);
                    }

                    string_literal574=(Token)match(input,SUPER,FOLLOW_SUPER_in_identifierSuffix8612); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal574_tree = 
                    (Object)adaptor.create(string_literal574)
                    ;
                    adaptor.addChild(root_0, string_literal574_tree);
                    }

                    pushFollow(FOLLOW_arguments_in_identifierSuffix8614);
                    arguments575=arguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, arguments575.getTree());

                    }
                    break;
                case 8 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1250:9: innerCreator
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_innerCreator_in_identifierSuffix8624);
                    innerCreator576=innerCreator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, innerCreator576.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 93, identifierSuffix_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "identifierSuffix"


    public static class selector_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "selector"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1254:1: selector : ( '.' IDENTIFIER ( arguments )? | '.' 'this' | '.' 'super' superSuffix | innerCreator | '[' expression ']' );
    public final JavaTreeParser.selector_return selector() throws RecognitionException {
        JavaTreeParser.selector_return retval = new JavaTreeParser.selector_return();
        retval.start = input.LT(1);

        int selector_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal577=null;
        Token IDENTIFIER578=null;
        Token char_literal580=null;
        Token string_literal581=null;
        Token char_literal582=null;
        Token string_literal583=null;
        Token char_literal586=null;
        Token char_literal588=null;
        JavaTreeParser.arguments_return arguments579 =null;

        JavaTreeParser.superSuffix_return superSuffix584 =null;

        JavaTreeParser.innerCreator_return innerCreator585 =null;

        JavaTreeParser.expression_return expression587 =null;


        Object char_literal577_tree=null;
        Object IDENTIFIER578_tree=null;
        Object char_literal580_tree=null;
        Object string_literal581_tree=null;
        Object char_literal582_tree=null;
        Object string_literal583_tree=null;
        Object char_literal586_tree=null;
        Object char_literal588_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 94) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1255:5: ( '.' IDENTIFIER ( arguments )? | '.' 'this' | '.' 'super' superSuffix | innerCreator | '[' expression ']' )
            int alt157=5;
            int LA157_0 = input.LA(1);

            if ( (LA157_0==DOT) ) {
                switch ( input.LA(2) ) {
                case IDENTIFIER:
                    {
                    alt157=1;
                    }
                    break;
                case THIS:
                    {
                    alt157=2;
                    }
                    break;
                case SUPER:
                    {
                    alt157=3;
                    }
                    break;
                case NEW:
                    {
                    alt157=4;
                    }
                    break;
                default:
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 157, 1, input);

                    throw nvae;

                }

            }
            else if ( (LA157_0==LBRACKET) ) {
                alt157=5;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 157, 0, input);

                throw nvae;

            }
            switch (alt157) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1255:9: '.' IDENTIFIER ( arguments )?
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal577=(Token)match(input,DOT,FOLLOW_DOT_in_selector8646); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal577_tree = 
                    (Object)adaptor.create(char_literal577)
                    ;
                    adaptor.addChild(root_0, char_literal577_tree);
                    }

                    IDENTIFIER578=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_selector8648); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    IDENTIFIER578_tree = 
                    (Object)adaptor.create(IDENTIFIER578)
                    ;
                    adaptor.addChild(root_0, IDENTIFIER578_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1256:9: ( arguments )?
                    int alt156=2;
                    int LA156_0 = input.LA(1);

                    if ( (LA156_0==LPAREN) ) {
                        alt156=1;
                    }
                    switch (alt156) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1256:10: arguments
                            {
                            pushFollow(FOLLOW_arguments_in_selector8659);
                            arguments579=arguments();

                            state._fsp--;
                            if (state.failed) return retval;
                            if ( state.backtracking==0 ) adaptor.addChild(root_0, arguments579.getTree());

                            }
                            break;

                    }


                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1258:9: '.' 'this'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal580=(Token)match(input,DOT,FOLLOW_DOT_in_selector8680); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal580_tree = 
                    (Object)adaptor.create(char_literal580)
                    ;
                    adaptor.addChild(root_0, char_literal580_tree);
                    }

                    string_literal581=(Token)match(input,THIS,FOLLOW_THIS_in_selector8682); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal581_tree = 
                    (Object)adaptor.create(string_literal581)
                    ;
                    adaptor.addChild(root_0, string_literal581_tree);
                    }

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1259:9: '.' 'super' superSuffix
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal582=(Token)match(input,DOT,FOLLOW_DOT_in_selector8692); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal582_tree = 
                    (Object)adaptor.create(char_literal582)
                    ;
                    adaptor.addChild(root_0, char_literal582_tree);
                    }

                    string_literal583=(Token)match(input,SUPER,FOLLOW_SUPER_in_selector8694); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal583_tree = 
                    (Object)adaptor.create(string_literal583)
                    ;
                    adaptor.addChild(root_0, string_literal583_tree);
                    }

                    pushFollow(FOLLOW_superSuffix_in_selector8704);
                    superSuffix584=superSuffix();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, superSuffix584.getTree());

                    }
                    break;
                case 4 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1261:9: innerCreator
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_innerCreator_in_selector8714);
                    innerCreator585=innerCreator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, innerCreator585.getTree());

                    }
                    break;
                case 5 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1262:9: '[' expression ']'
                    {
                    root_0 = (Object)adaptor.nil();


                    char_literal586=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_selector8724); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal586_tree = 
                    (Object)adaptor.create(char_literal586)
                    ;
                    adaptor.addChild(root_0, char_literal586_tree);
                    }

                    pushFollow(FOLLOW_expression_in_selector8726);
                    expression587=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression587.getTree());

                    char_literal588=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_selector8728); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal588_tree = 
                    (Object)adaptor.create(char_literal588)
                    ;
                    adaptor.addChild(root_0, char_literal588_tree);
                    }

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 94, selector_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "selector"


    public static class creator_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "creator"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1265:1: creator : ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest | 'new' classOrInterfaceType classCreatorRest | arrayCreator );
    public final JavaTreeParser.creator_return creator() throws RecognitionException {
        JavaTreeParser.creator_return retval = new JavaTreeParser.creator_return();
        retval.start = input.LT(1);

        int creator_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal589=null;
        Token string_literal593=null;
        JavaTreeParser.nonWildcardTypeArguments_return nonWildcardTypeArguments590 =null;

        JavaTreeParser.classOrInterfaceType_return classOrInterfaceType591 =null;

        JavaTreeParser.classCreatorRest_return classCreatorRest592 =null;

        JavaTreeParser.classOrInterfaceType_return classOrInterfaceType594 =null;

        JavaTreeParser.classCreatorRest_return classCreatorRest595 =null;

        JavaTreeParser.arrayCreator_return arrayCreator596 =null;


        Object string_literal589_tree=null;
        Object string_literal593_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 95) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1266:5: ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest | 'new' classOrInterfaceType classCreatorRest | arrayCreator )
            int alt158=3;
            int LA158_0 = input.LA(1);

            if ( (LA158_0==NEW) ) {
                int LA158_1 = input.LA(2);

                if ( (synpred253_JavaTree()) ) {
                    alt158=1;
                }
                else if ( (synpred254_JavaTree()) ) {
                    alt158=2;
                }
                else if ( (true) ) {
                    alt158=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 158, 1, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 158, 0, input);

                throw nvae;

            }
            switch (alt158) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1266:9: 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal589=(Token)match(input,NEW,FOLLOW_NEW_in_creator8748); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal589_tree = 
                    (Object)adaptor.create(string_literal589)
                    ;
                    adaptor.addChild(root_0, string_literal589_tree);
                    }

                    pushFollow(FOLLOW_nonWildcardTypeArguments_in_creator8750);
                    nonWildcardTypeArguments590=nonWildcardTypeArguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, nonWildcardTypeArguments590.getTree());

                    pushFollow(FOLLOW_classOrInterfaceType_in_creator8752);
                    classOrInterfaceType591=classOrInterfaceType();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, classOrInterfaceType591.getTree());

                    pushFollow(FOLLOW_classCreatorRest_in_creator8754);
                    classCreatorRest592=classCreatorRest();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, classCreatorRest592.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1267:9: 'new' classOrInterfaceType classCreatorRest
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal593=(Token)match(input,NEW,FOLLOW_NEW_in_creator8764); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal593_tree = 
                    (Object)adaptor.create(string_literal593)
                    ;
                    adaptor.addChild(root_0, string_literal593_tree);
                    }

                    pushFollow(FOLLOW_classOrInterfaceType_in_creator8766);
                    classOrInterfaceType594=classOrInterfaceType();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, classOrInterfaceType594.getTree());

                    pushFollow(FOLLOW_classCreatorRest_in_creator8768);
                    classCreatorRest595=classCreatorRest();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, classCreatorRest595.getTree());

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1268:9: arrayCreator
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_arrayCreator_in_creator8778);
                    arrayCreator596=arrayCreator();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, arrayCreator596.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 95, creator_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "creator"


    public static class arrayCreator_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "arrayCreator"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1271:1: arrayCreator : ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer | 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )* );
    public final JavaTreeParser.arrayCreator_return arrayCreator() throws RecognitionException {
        JavaTreeParser.arrayCreator_return retval = new JavaTreeParser.arrayCreator_return();
        retval.start = input.LT(1);

        int arrayCreator_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal597=null;
        Token char_literal599=null;
        Token char_literal600=null;
        Token char_literal601=null;
        Token char_literal602=null;
        Token string_literal604=null;
        Token char_literal606=null;
        Token char_literal608=null;
        Token char_literal609=null;
        Token char_literal611=null;
        Token char_literal612=null;
        Token char_literal613=null;
        JavaTreeParser.createdName_return createdName598 =null;

        JavaTreeParser.arrayInitializer_return arrayInitializer603 =null;

        JavaTreeParser.createdName_return createdName605 =null;

        JavaTreeParser.expression_return expression607 =null;

        JavaTreeParser.expression_return expression610 =null;


        Object string_literal597_tree=null;
        Object char_literal599_tree=null;
        Object char_literal600_tree=null;
        Object char_literal601_tree=null;
        Object char_literal602_tree=null;
        Object string_literal604_tree=null;
        Object char_literal606_tree=null;
        Object char_literal608_tree=null;
        Object char_literal609_tree=null;
        Object char_literal611_tree=null;
        Object char_literal612_tree=null;
        Object char_literal613_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 96) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1272:5: ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer | 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )* )
            int alt162=2;
            int LA162_0 = input.LA(1);

            if ( (LA162_0==NEW) ) {
                int LA162_1 = input.LA(2);

                if ( (synpred256_JavaTree()) ) {
                    alt162=1;
                }
                else if ( (true) ) {
                    alt162=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return retval;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 162, 1, input);

                    throw nvae;

                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 162, 0, input);

                throw nvae;

            }
            switch (alt162) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1272:9: 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal597=(Token)match(input,NEW,FOLLOW_NEW_in_arrayCreator8798); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal597_tree = 
                    (Object)adaptor.create(string_literal597)
                    ;
                    adaptor.addChild(root_0, string_literal597_tree);
                    }

                    pushFollow(FOLLOW_createdName_in_arrayCreator8800);
                    createdName598=createdName();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, createdName598.getTree());

                    char_literal599=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator8810); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal599_tree = 
                    (Object)adaptor.create(char_literal599)
                    ;
                    adaptor.addChild(root_0, char_literal599_tree);
                    }

                    char_literal600=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator8812); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal600_tree = 
                    (Object)adaptor.create(char_literal600)
                    ;
                    adaptor.addChild(root_0, char_literal600_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1274:9: ( '[' ']' )*
                    loop159:
                    do {
                        int alt159=2;
                        int LA159_0 = input.LA(1);

                        if ( (LA159_0==LBRACKET) ) {
                            alt159=1;
                        }


                        switch (alt159) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1274:10: '[' ']'
                    	    {
                    	    char_literal601=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator8823); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal601_tree = 
                    	    (Object)adaptor.create(char_literal601)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal601_tree);
                    	    }

                    	    char_literal602=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator8825); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal602_tree = 
                    	    (Object)adaptor.create(char_literal602)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal602_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    break loop159;
                        }
                    } while (true);


                    pushFollow(FOLLOW_arrayInitializer_in_arrayCreator8846);
                    arrayInitializer603=arrayInitializer();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, arrayInitializer603.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1278:9: 'new' createdName '[' expression ']' ( '[' expression ']' )* ( '[' ']' )*
                    {
                    root_0 = (Object)adaptor.nil();


                    string_literal604=(Token)match(input,NEW,FOLLOW_NEW_in_arrayCreator8857); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal604_tree = 
                    (Object)adaptor.create(string_literal604)
                    ;
                    adaptor.addChild(root_0, string_literal604_tree);
                    }

                    pushFollow(FOLLOW_createdName_in_arrayCreator8859);
                    createdName605=createdName();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, createdName605.getTree());

                    char_literal606=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator8869); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal606_tree = 
                    (Object)adaptor.create(char_literal606)
                    ;
                    adaptor.addChild(root_0, char_literal606_tree);
                    }

                    pushFollow(FOLLOW_expression_in_arrayCreator8871);
                    expression607=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression607.getTree());

                    char_literal608=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator8881); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal608_tree = 
                    (Object)adaptor.create(char_literal608)
                    ;
                    adaptor.addChild(root_0, char_literal608_tree);
                    }

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1281:9: ( '[' expression ']' )*
                    loop160:
                    do {
                        int alt160=2;
                        int LA160_0 = input.LA(1);

                        if ( (LA160_0==LBRACKET) ) {
                            int LA160_1 = input.LA(2);

                            if ( (synpred257_JavaTree()) ) {
                                alt160=1;
                            }


                        }


                        switch (alt160) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1281:13: '[' expression ']'
                    	    {
                    	    char_literal609=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator8895); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal609_tree = 
                    	    (Object)adaptor.create(char_literal609)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal609_tree);
                    	    }

                    	    pushFollow(FOLLOW_expression_in_arrayCreator8897);
                    	    expression610=expression();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression610.getTree());

                    	    char_literal611=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator8911); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal611_tree = 
                    	    (Object)adaptor.create(char_literal611)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal611_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    break loop160;
                        }
                    } while (true);


                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1284:9: ( '[' ']' )*
                    loop161:
                    do {
                        int alt161=2;
                        int LA161_0 = input.LA(1);

                        if ( (LA161_0==LBRACKET) ) {
                            int LA161_2 = input.LA(2);

                            if ( (LA161_2==RBRACKET) ) {
                                alt161=1;
                            }


                        }


                        switch (alt161) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1284:10: '[' ']'
                    	    {
                    	    char_literal612=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_arrayCreator8933); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal612_tree = 
                    	    (Object)adaptor.create(char_literal612)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal612_tree);
                    	    }

                    	    char_literal613=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_arrayCreator8935); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal613_tree = 
                    	    (Object)adaptor.create(char_literal613)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal613_tree);
                    	    }

                    	    }
                    	    break;

                    	default :
                    	    break loop161;
                        }
                    } while (true);


                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 96, arrayCreator_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "arrayCreator"


    public static class variableInitializer_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "variableInitializer"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1288:1: variableInitializer : ( arrayInitializer | expression );
    public final JavaTreeParser.variableInitializer_return variableInitializer() throws RecognitionException {
        JavaTreeParser.variableInitializer_return retval = new JavaTreeParser.variableInitializer_return();
        retval.start = input.LT(1);

        int variableInitializer_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.arrayInitializer_return arrayInitializer614 =null;

        JavaTreeParser.expression_return expression615 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 97) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1289:5: ( arrayInitializer | expression )
            int alt163=2;
            int LA163_0 = input.LA(1);

            if ( (LA163_0==LBRACE) ) {
                alt163=1;
            }
            else if ( (LA163_0==BANG||LA163_0==BOOLEAN||LA163_0==BYTE||(LA163_0 >= CHAR && LA163_0 <= CHARLITERAL)||(LA163_0 >= DOUBLE && LA163_0 <= DOUBLELITERAL)||LA163_0==FALSE||(LA163_0 >= FLOAT && LA163_0 <= FLOATLITERAL)||LA163_0==IDENTIFIER||LA163_0==INT||LA163_0==INTLITERAL||(LA163_0 >= LONG && LA163_0 <= LPAREN)||LA163_0==NEW||LA163_0==NULL||LA163_0==PLUS||LA163_0==PLUSPLUS||LA163_0==SHORT||(LA163_0 >= STRINGLITERAL && LA163_0 <= SUB)||(LA163_0 >= SUBSUB && LA163_0 <= SUPER)||LA163_0==THIS||LA163_0==TILDE||LA163_0==TRUE||LA163_0==VOID) ) {
                alt163=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 163, 0, input);

                throw nvae;

            }
            switch (alt163) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1289:9: arrayInitializer
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_arrayInitializer_in_variableInitializer8966);
                    arrayInitializer614=arrayInitializer();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, arrayInitializer614.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1290:9: expression
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_expression_in_variableInitializer8976);
                    expression615=expression();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expression615.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 97, variableInitializer_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "variableInitializer"


    public static class arrayInitializer_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "arrayInitializer"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1293:1: arrayInitializer : '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}' ;
    public final JavaTreeParser.arrayInitializer_return arrayInitializer() throws RecognitionException {
        JavaTreeParser.arrayInitializer_return retval = new JavaTreeParser.arrayInitializer_return();
        retval.start = input.LT(1);

        int arrayInitializer_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal616=null;
        Token char_literal618=null;
        Token char_literal620=null;
        Token char_literal621=null;
        JavaTreeParser.variableInitializer_return variableInitializer617 =null;

        JavaTreeParser.variableInitializer_return variableInitializer619 =null;


        Object char_literal616_tree=null;
        Object char_literal618_tree=null;
        Object char_literal620_tree=null;
        Object char_literal621_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 98) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1294:5: ( '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1294:9: '{' ( variableInitializer ( ',' variableInitializer )* )? ( ',' )? '}'
            {
            root_0 = (Object)adaptor.nil();


            char_literal616=(Token)match(input,LBRACE,FOLLOW_LBRACE_in_arrayInitializer8996); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal616_tree = 
            (Object)adaptor.create(char_literal616)
            ;
            adaptor.addChild(root_0, char_literal616_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1295:13: ( variableInitializer ( ',' variableInitializer )* )?
            int alt165=2;
            int LA165_0 = input.LA(1);

            if ( (LA165_0==BANG||LA165_0==BOOLEAN||LA165_0==BYTE||(LA165_0 >= CHAR && LA165_0 <= CHARLITERAL)||(LA165_0 >= DOUBLE && LA165_0 <= DOUBLELITERAL)||LA165_0==FALSE||(LA165_0 >= FLOAT && LA165_0 <= FLOATLITERAL)||LA165_0==IDENTIFIER||LA165_0==INT||LA165_0==INTLITERAL||LA165_0==LBRACE||(LA165_0 >= LONG && LA165_0 <= LPAREN)||LA165_0==NEW||LA165_0==NULL||LA165_0==PLUS||LA165_0==PLUSPLUS||LA165_0==SHORT||(LA165_0 >= STRINGLITERAL && LA165_0 <= SUB)||(LA165_0 >= SUBSUB && LA165_0 <= SUPER)||LA165_0==THIS||LA165_0==TILDE||LA165_0==TRUE||LA165_0==VOID) ) {
                alt165=1;
            }
            switch (alt165) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1295:14: variableInitializer ( ',' variableInitializer )*
                    {
                    pushFollow(FOLLOW_variableInitializer_in_arrayInitializer9012);
                    variableInitializer617=variableInitializer();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, variableInitializer617.getTree());

                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1296:17: ( ',' variableInitializer )*
                    loop164:
                    do {
                        int alt164=2;
                        int LA164_0 = input.LA(1);

                        if ( (LA164_0==COMMA) ) {
                            int LA164_1 = input.LA(2);

                            if ( (LA164_1==BANG||LA164_1==BOOLEAN||LA164_1==BYTE||(LA164_1 >= CHAR && LA164_1 <= CHARLITERAL)||(LA164_1 >= DOUBLE && LA164_1 <= DOUBLELITERAL)||LA164_1==FALSE||(LA164_1 >= FLOAT && LA164_1 <= FLOATLITERAL)||LA164_1==IDENTIFIER||LA164_1==INT||LA164_1==INTLITERAL||LA164_1==LBRACE||(LA164_1 >= LONG && LA164_1 <= LPAREN)||LA164_1==NEW||LA164_1==NULL||LA164_1==PLUS||LA164_1==PLUSPLUS||LA164_1==SHORT||(LA164_1 >= STRINGLITERAL && LA164_1 <= SUB)||(LA164_1 >= SUBSUB && LA164_1 <= SUPER)||LA164_1==THIS||LA164_1==TILDE||LA164_1==TRUE||LA164_1==VOID) ) {
                                alt164=1;
                            }


                        }


                        switch (alt164) {
                    	case 1 :
                    	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1296:18: ',' variableInitializer
                    	    {
                    	    char_literal618=(Token)match(input,COMMA,FOLLOW_COMMA_in_arrayInitializer9031); if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) {
                    	    char_literal618_tree = 
                    	    (Object)adaptor.create(char_literal618)
                    	    ;
                    	    adaptor.addChild(root_0, char_literal618_tree);
                    	    }

                    	    pushFollow(FOLLOW_variableInitializer_in_arrayInitializer9033);
                    	    variableInitializer619=variableInitializer();

                    	    state._fsp--;
                    	    if (state.failed) return retval;
                    	    if ( state.backtracking==0 ) adaptor.addChild(root_0, variableInitializer619.getTree());

                    	    }
                    	    break;

                    	default :
                    	    break loop164;
                        }
                    } while (true);


                    }
                    break;

            }


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1299:13: ( ',' )?
            int alt166=2;
            int LA166_0 = input.LA(1);

            if ( (LA166_0==COMMA) ) {
                alt166=1;
            }
            switch (alt166) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1299:14: ','
                    {
                    char_literal620=(Token)match(input,COMMA,FOLLOW_COMMA_in_arrayInitializer9083); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    char_literal620_tree = 
                    (Object)adaptor.create(char_literal620)
                    ;
                    adaptor.addChild(root_0, char_literal620_tree);
                    }

                    }
                    break;

            }


            char_literal621=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_arrayInitializer9096); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal621_tree = 
            (Object)adaptor.create(char_literal621)
            ;
            adaptor.addChild(root_0, char_literal621_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 98, arrayInitializer_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "arrayInitializer"


    public static class createdName_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "createdName"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1304:1: createdName : ( classOrInterfaceType | primitiveType );
    public final JavaTreeParser.createdName_return createdName() throws RecognitionException {
        JavaTreeParser.createdName_return retval = new JavaTreeParser.createdName_return();
        retval.start = input.LT(1);

        int createdName_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.classOrInterfaceType_return classOrInterfaceType622 =null;

        JavaTreeParser.primitiveType_return primitiveType623 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 99) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1305:5: ( classOrInterfaceType | primitiveType )
            int alt167=2;
            int LA167_0 = input.LA(1);

            if ( (LA167_0==IDENTIFIER) ) {
                alt167=1;
            }
            else if ( (LA167_0==BOOLEAN||LA167_0==BYTE||LA167_0==CHAR||LA167_0==DOUBLE||LA167_0==FLOAT||LA167_0==INT||LA167_0==LONG||LA167_0==SHORT) ) {
                alt167=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 167, 0, input);

                throw nvae;

            }
            switch (alt167) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1305:9: classOrInterfaceType
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_classOrInterfaceType_in_createdName9130);
                    classOrInterfaceType622=classOrInterfaceType();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, classOrInterfaceType622.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1306:9: primitiveType
                    {
                    root_0 = (Object)adaptor.nil();


                    pushFollow(FOLLOW_primitiveType_in_createdName9140);
                    primitiveType623=primitiveType();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, primitiveType623.getTree());

                    }
                    break;

            }
            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 99, createdName_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "createdName"


    public static class innerCreator_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "innerCreator"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1309:1: innerCreator : '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest ;
    public final JavaTreeParser.innerCreator_return innerCreator() throws RecognitionException {
        JavaTreeParser.innerCreator_return retval = new JavaTreeParser.innerCreator_return();
        retval.start = input.LT(1);

        int innerCreator_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal624=null;
        Token string_literal625=null;
        Token IDENTIFIER627=null;
        JavaTreeParser.nonWildcardTypeArguments_return nonWildcardTypeArguments626 =null;

        JavaTreeParser.typeArguments_return typeArguments628 =null;

        JavaTreeParser.classCreatorRest_return classCreatorRest629 =null;


        Object char_literal624_tree=null;
        Object string_literal625_tree=null;
        Object IDENTIFIER627_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 100) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1310:5: ( '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1310:9: '.' 'new' ( nonWildcardTypeArguments )? IDENTIFIER ( typeArguments )? classCreatorRest
            {
            root_0 = (Object)adaptor.nil();


            char_literal624=(Token)match(input,DOT,FOLLOW_DOT_in_innerCreator9161); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal624_tree = 
            (Object)adaptor.create(char_literal624)
            ;
            adaptor.addChild(root_0, char_literal624_tree);
            }

            string_literal625=(Token)match(input,NEW,FOLLOW_NEW_in_innerCreator9163); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            string_literal625_tree = 
            (Object)adaptor.create(string_literal625)
            ;
            adaptor.addChild(root_0, string_literal625_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1311:9: ( nonWildcardTypeArguments )?
            int alt168=2;
            int LA168_0 = input.LA(1);

            if ( (LA168_0==LT) ) {
                alt168=1;
            }
            switch (alt168) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1311:10: nonWildcardTypeArguments
                    {
                    pushFollow(FOLLOW_nonWildcardTypeArguments_in_innerCreator9174);
                    nonWildcardTypeArguments626=nonWildcardTypeArguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, nonWildcardTypeArguments626.getTree());

                    }
                    break;

            }


            IDENTIFIER627=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_innerCreator9195); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER627_tree = 
            (Object)adaptor.create(IDENTIFIER627)
            ;
            adaptor.addChild(root_0, IDENTIFIER627_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1314:9: ( typeArguments )?
            int alt169=2;
            int LA169_0 = input.LA(1);

            if ( (LA169_0==LT) ) {
                alt169=1;
            }
            switch (alt169) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1314:10: typeArguments
                    {
                    pushFollow(FOLLOW_typeArguments_in_innerCreator9206);
                    typeArguments628=typeArguments();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, typeArguments628.getTree());

                    }
                    break;

            }


            pushFollow(FOLLOW_classCreatorRest_in_innerCreator9227);
            classCreatorRest629=classCreatorRest();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, classCreatorRest629.getTree());

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 100, innerCreator_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "innerCreator"


    public static class classCreatorRest_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "classCreatorRest"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1320:1: classCreatorRest : arguments ( classBody )? ;
    public final JavaTreeParser.classCreatorRest_return classCreatorRest() throws RecognitionException {
        JavaTreeParser.classCreatorRest_return retval = new JavaTreeParser.classCreatorRest_return();
        retval.start = input.LT(1);

        int classCreatorRest_StartIndex = input.index();

        Object root_0 = null;

        JavaTreeParser.arguments_return arguments630 =null;

        JavaTreeParser.classBody_return classBody631 =null;



        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 101) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1321:5: ( arguments ( classBody )? )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1321:9: arguments ( classBody )?
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_arguments_in_classCreatorRest9248);
            arguments630=arguments();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, arguments630.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1322:9: ( classBody )?
            int alt170=2;
            int LA170_0 = input.LA(1);

            if ( (LA170_0==LBRACE) ) {
                alt170=1;
            }
            switch (alt170) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1322:10: classBody
                    {
                    pushFollow(FOLLOW_classBody_in_classCreatorRest9259);
                    classBody631=classBody();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, classBody631.getTree());

                    }
                    break;

            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 101, classCreatorRest_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "classCreatorRest"


    public static class nonWildcardTypeArguments_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "nonWildcardTypeArguments"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1327:1: nonWildcardTypeArguments : '<' typeList '>' ;
    public final JavaTreeParser.nonWildcardTypeArguments_return nonWildcardTypeArguments() throws RecognitionException {
        JavaTreeParser.nonWildcardTypeArguments_return retval = new JavaTreeParser.nonWildcardTypeArguments_return();
        retval.start = input.LT(1);

        int nonWildcardTypeArguments_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal632=null;
        Token char_literal634=null;
        JavaTreeParser.typeList_return typeList633 =null;


        Object char_literal632_tree=null;
        Object char_literal634_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 102) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1328:5: ( '<' typeList '>' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1328:9: '<' typeList '>'
            {
            root_0 = (Object)adaptor.nil();


            char_literal632=(Token)match(input,LT,FOLLOW_LT_in_nonWildcardTypeArguments9291); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal632_tree = 
            (Object)adaptor.create(char_literal632)
            ;
            adaptor.addChild(root_0, char_literal632_tree);
            }

            pushFollow(FOLLOW_typeList_in_nonWildcardTypeArguments9293);
            typeList633=typeList();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, typeList633.getTree());

            char_literal634=(Token)match(input,GT,FOLLOW_GT_in_nonWildcardTypeArguments9303); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal634_tree = 
            (Object)adaptor.create(char_literal634)
            ;
            adaptor.addChild(root_0, char_literal634_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 102, nonWildcardTypeArguments_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "nonWildcardTypeArguments"


    public static class arguments_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "arguments"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1332:1: arguments : '(' ( expressionList )? ')' ;
    public final JavaTreeParser.arguments_return arguments() throws RecognitionException {
        JavaTreeParser.arguments_return retval = new JavaTreeParser.arguments_return();
        retval.start = input.LT(1);

        int arguments_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal635=null;
        Token char_literal637=null;
        JavaTreeParser.expressionList_return expressionList636 =null;


        Object char_literal635_tree=null;
        Object char_literal637_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 103) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1333:5: ( '(' ( expressionList )? ')' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1333:9: '(' ( expressionList )? ')'
            {
            root_0 = (Object)adaptor.nil();


            char_literal635=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_arguments9323); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal635_tree = 
            (Object)adaptor.create(char_literal635)
            ;
            adaptor.addChild(root_0, char_literal635_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1333:13: ( expressionList )?
            int alt171=2;
            int LA171_0 = input.LA(1);

            if ( (LA171_0==BANG||LA171_0==BOOLEAN||LA171_0==BYTE||(LA171_0 >= CHAR && LA171_0 <= CHARLITERAL)||(LA171_0 >= DOUBLE && LA171_0 <= DOUBLELITERAL)||LA171_0==FALSE||(LA171_0 >= FLOAT && LA171_0 <= FLOATLITERAL)||LA171_0==IDENTIFIER||LA171_0==INT||LA171_0==INTLITERAL||(LA171_0 >= LONG && LA171_0 <= LPAREN)||LA171_0==NEW||LA171_0==NULL||LA171_0==PLUS||LA171_0==PLUSPLUS||LA171_0==SHORT||(LA171_0 >= STRINGLITERAL && LA171_0 <= SUB)||(LA171_0 >= SUBSUB && LA171_0 <= SUPER)||LA171_0==THIS||LA171_0==TILDE||LA171_0==TRUE||LA171_0==VOID) ) {
                alt171=1;
            }
            switch (alt171) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1333:14: expressionList
                    {
                    pushFollow(FOLLOW_expressionList_in_arguments9326);
                    expressionList636=expressionList();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, expressionList636.getTree());

                    }
                    break;

            }


            char_literal637=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_arguments9339); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal637_tree = 
            (Object)adaptor.create(char_literal637)
            ;
            adaptor.addChild(root_0, char_literal637_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 103, arguments_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "arguments"


    public static class literal_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "literal"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1337:1: literal : ( INTLITERAL | LONGLITERAL | FLOATLITERAL | DOUBLELITERAL | CHARLITERAL | STRINGLITERAL | TRUE | FALSE | NULL );
    public final JavaTreeParser.literal_return literal() throws RecognitionException {
        JavaTreeParser.literal_return retval = new JavaTreeParser.literal_return();
        retval.start = input.LT(1);

        int literal_StartIndex = input.index();

        Object root_0 = null;

        Token set638=null;

        Object set638_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 104) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1338:5: ( INTLITERAL | LONGLITERAL | FLOATLITERAL | DOUBLELITERAL | CHARLITERAL | STRINGLITERAL | TRUE | FALSE | NULL )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:
            {
            root_0 = (Object)adaptor.nil();


            set638=(Token)input.LT(1);

            if ( input.LA(1)==CHARLITERAL||input.LA(1)==DOUBLELITERAL||input.LA(1)==FALSE||input.LA(1)==FLOATLITERAL||input.LA(1)==INTLITERAL||input.LA(1)==LONGLITERAL||input.LA(1)==NULL||input.LA(1)==STRINGLITERAL||input.LA(1)==TRUE ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                (Object)adaptor.create(set638)
                );
                state.errorRecovery=false;
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 104, literal_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "literal"


    public static class classHeader_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "classHeader"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1353:1: classHeader : modifiers 'class' IDENTIFIER ;
    public final JavaTreeParser.classHeader_return classHeader() throws RecognitionException {
        JavaTreeParser.classHeader_return retval = new JavaTreeParser.classHeader_return();
        retval.start = input.LT(1);

        int classHeader_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal640=null;
        Token IDENTIFIER641=null;
        JavaTreeParser.modifiers_return modifiers639 =null;


        Object string_literal640_tree=null;
        Object IDENTIFIER641_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 105) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1354:5: ( modifiers 'class' IDENTIFIER )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1354:9: modifiers 'class' IDENTIFIER
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_modifiers_in_classHeader9463);
            modifiers639=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, modifiers639.getTree());

            string_literal640=(Token)match(input,CLASS,FOLLOW_CLASS_in_classHeader9465); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            string_literal640_tree = 
            (Object)adaptor.create(string_literal640)
            ;
            adaptor.addChild(root_0, string_literal640_tree);
            }

            IDENTIFIER641=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_classHeader9467); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER641_tree = 
            (Object)adaptor.create(IDENTIFIER641)
            ;
            adaptor.addChild(root_0, IDENTIFIER641_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 105, classHeader_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "classHeader"


    public static class enumHeader_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "enumHeader"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1357:1: enumHeader : modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER ;
    public final JavaTreeParser.enumHeader_return enumHeader() throws RecognitionException {
        JavaTreeParser.enumHeader_return retval = new JavaTreeParser.enumHeader_return();
        retval.start = input.LT(1);

        int enumHeader_StartIndex = input.index();

        Object root_0 = null;

        Token set643=null;
        Token IDENTIFIER644=null;
        JavaTreeParser.modifiers_return modifiers642 =null;


        Object set643_tree=null;
        Object IDENTIFIER644_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 106) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1358:5: ( modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1358:9: modifiers ( 'enum' | IDENTIFIER ) IDENTIFIER
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_modifiers_in_enumHeader9487);
            modifiers642=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, modifiers642.getTree());

            set643=(Token)input.LT(1);

            if ( input.LA(1)==ENUM||input.LA(1)==IDENTIFIER ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                (Object)adaptor.create(set643)
                );
                state.errorRecovery=false;
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            IDENTIFIER644=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumHeader9495); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER644_tree = 
            (Object)adaptor.create(IDENTIFIER644)
            ;
            adaptor.addChild(root_0, IDENTIFIER644_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 106, enumHeader_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "enumHeader"


    public static class interfaceHeader_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "interfaceHeader"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1361:1: interfaceHeader : modifiers 'interface' IDENTIFIER ;
    public final JavaTreeParser.interfaceHeader_return interfaceHeader() throws RecognitionException {
        JavaTreeParser.interfaceHeader_return retval = new JavaTreeParser.interfaceHeader_return();
        retval.start = input.LT(1);

        int interfaceHeader_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal646=null;
        Token IDENTIFIER647=null;
        JavaTreeParser.modifiers_return modifiers645 =null;


        Object string_literal646_tree=null;
        Object IDENTIFIER647_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 107) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1362:5: ( modifiers 'interface' IDENTIFIER )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1362:9: modifiers 'interface' IDENTIFIER
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_modifiers_in_interfaceHeader9515);
            modifiers645=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, modifiers645.getTree());

            string_literal646=(Token)match(input,INTERFACE,FOLLOW_INTERFACE_in_interfaceHeader9517); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            string_literal646_tree = 
            (Object)adaptor.create(string_literal646)
            ;
            adaptor.addChild(root_0, string_literal646_tree);
            }

            IDENTIFIER647=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_interfaceHeader9519); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER647_tree = 
            (Object)adaptor.create(IDENTIFIER647)
            ;
            adaptor.addChild(root_0, IDENTIFIER647_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 107, interfaceHeader_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "interfaceHeader"


    public static class annotationHeader_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "annotationHeader"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1365:1: annotationHeader : modifiers '@' 'interface' IDENTIFIER ;
    public final JavaTreeParser.annotationHeader_return annotationHeader() throws RecognitionException {
        JavaTreeParser.annotationHeader_return retval = new JavaTreeParser.annotationHeader_return();
        retval.start = input.LT(1);

        int annotationHeader_StartIndex = input.index();

        Object root_0 = null;

        Token char_literal649=null;
        Token string_literal650=null;
        Token IDENTIFIER651=null;
        JavaTreeParser.modifiers_return modifiers648 =null;


        Object char_literal649_tree=null;
        Object string_literal650_tree=null;
        Object IDENTIFIER651_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 108) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1366:5: ( modifiers '@' 'interface' IDENTIFIER )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1366:9: modifiers '@' 'interface' IDENTIFIER
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_modifiers_in_annotationHeader9539);
            modifiers648=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, modifiers648.getTree());

            char_literal649=(Token)match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_annotationHeader9541); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal649_tree = 
            (Object)adaptor.create(char_literal649)
            ;
            adaptor.addChild(root_0, char_literal649_tree);
            }

            string_literal650=(Token)match(input,INTERFACE,FOLLOW_INTERFACE_in_annotationHeader9543); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            string_literal650_tree = 
            (Object)adaptor.create(string_literal650)
            ;
            adaptor.addChild(root_0, string_literal650_tree);
            }

            IDENTIFIER651=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_annotationHeader9545); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER651_tree = 
            (Object)adaptor.create(IDENTIFIER651)
            ;
            adaptor.addChild(root_0, IDENTIFIER651_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 108, annotationHeader_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "annotationHeader"


    public static class typeHeader_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "typeHeader"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1369:1: typeHeader : modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER ;
    public final JavaTreeParser.typeHeader_return typeHeader() throws RecognitionException {
        JavaTreeParser.typeHeader_return retval = new JavaTreeParser.typeHeader_return();
        retval.start = input.LT(1);

        int typeHeader_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal653=null;
        Token string_literal654=null;
        Token char_literal655=null;
        Token string_literal656=null;
        Token IDENTIFIER657=null;
        JavaTreeParser.modifiers_return modifiers652 =null;


        Object string_literal653_tree=null;
        Object string_literal654_tree=null;
        Object char_literal655_tree=null;
        Object string_literal656_tree=null;
        Object IDENTIFIER657_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 109) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1370:5: ( modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1370:9: modifiers ( 'class' | 'enum' | ( ( '@' )? 'interface' ) ) IDENTIFIER
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_modifiers_in_typeHeader9565);
            modifiers652=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, modifiers652.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1370:19: ( 'class' | 'enum' | ( ( '@' )? 'interface' ) )
            int alt173=3;
            switch ( input.LA(1) ) {
            case CLASS:
                {
                alt173=1;
                }
                break;
            case ENUM:
                {
                alt173=2;
                }
                break;
            case INTERFACE:
            case MONKEYS_AT:
                {
                alt173=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return retval;}
                NoViableAltException nvae =
                    new NoViableAltException("", 173, 0, input);

                throw nvae;

            }

            switch (alt173) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1370:20: 'class'
                    {
                    string_literal653=(Token)match(input,CLASS,FOLLOW_CLASS_in_typeHeader9568); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal653_tree = 
                    (Object)adaptor.create(string_literal653)
                    ;
                    adaptor.addChild(root_0, string_literal653_tree);
                    }

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1370:28: 'enum'
                    {
                    string_literal654=(Token)match(input,ENUM,FOLLOW_ENUM_in_typeHeader9570); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal654_tree = 
                    (Object)adaptor.create(string_literal654)
                    ;
                    adaptor.addChild(root_0, string_literal654_tree);
                    }

                    }
                    break;
                case 3 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1370:35: ( ( '@' )? 'interface' )
                    {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1370:35: ( ( '@' )? 'interface' )
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1370:36: ( '@' )? 'interface'
                    {
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1370:36: ( '@' )?
                    int alt172=2;
                    int LA172_0 = input.LA(1);

                    if ( (LA172_0==MONKEYS_AT) ) {
                        alt172=1;
                    }
                    switch (alt172) {
                        case 1 :
                            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1370:36: '@'
                            {
                            char_literal655=(Token)match(input,MONKEYS_AT,FOLLOW_MONKEYS_AT_in_typeHeader9573); if (state.failed) return retval;
                            if ( state.backtracking==0 ) {
                            char_literal655_tree = 
                            (Object)adaptor.create(char_literal655)
                            ;
                            adaptor.addChild(root_0, char_literal655_tree);
                            }

                            }
                            break;

                    }


                    string_literal656=(Token)match(input,INTERFACE,FOLLOW_INTERFACE_in_typeHeader9577); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal656_tree = 
                    (Object)adaptor.create(string_literal656)
                    ;
                    adaptor.addChild(root_0, string_literal656_tree);
                    }

                    }


                    }
                    break;

            }


            IDENTIFIER657=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typeHeader9581); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER657_tree = 
            (Object)adaptor.create(IDENTIFIER657)
            ;
            adaptor.addChild(root_0, IDENTIFIER657_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 109, typeHeader_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "typeHeader"


    public static class methodHeader_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "methodHeader"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1373:1: methodHeader : modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '(' ;
    public final JavaTreeParser.methodHeader_return methodHeader() throws RecognitionException {
        JavaTreeParser.methodHeader_return retval = new JavaTreeParser.methodHeader_return();
        retval.start = input.LT(1);

        int methodHeader_StartIndex = input.index();

        Object root_0 = null;

        Token string_literal661=null;
        Token IDENTIFIER662=null;
        Token char_literal663=null;
        JavaTreeParser.modifiers_return modifiers658 =null;

        JavaTreeParser.typeParameters_return typeParameters659 =null;

        JavaTreeParser.type_return type660 =null;


        Object string_literal661_tree=null;
        Object IDENTIFIER662_tree=null;
        Object char_literal663_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 110) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1374:5: ( modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '(' )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1374:9: modifiers ( typeParameters )? ( type | 'void' )? IDENTIFIER '('
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_modifiers_in_methodHeader9601);
            modifiers658=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, modifiers658.getTree());

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1374:19: ( typeParameters )?
            int alt174=2;
            int LA174_0 = input.LA(1);

            if ( (LA174_0==LT) ) {
                alt174=1;
            }
            switch (alt174) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1374:19: typeParameters
                    {
                    pushFollow(FOLLOW_typeParameters_in_methodHeader9603);
                    typeParameters659=typeParameters();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, typeParameters659.getTree());

                    }
                    break;

            }


            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1374:35: ( type | 'void' )?
            int alt175=3;
            switch ( input.LA(1) ) {
                case IDENTIFIER:
                    {
                    int LA175_1 = input.LA(2);

                    if ( (LA175_1==DOT||LA175_1==IDENTIFIER||LA175_1==LBRACKET||LA175_1==LT) ) {
                        alt175=1;
                    }
                    }
                    break;
                case BOOLEAN:
                case BYTE:
                case CHAR:
                case DOUBLE:
                case FLOAT:
                case INT:
                case LONG:
                case SHORT:
                    {
                    alt175=1;
                    }
                    break;
                case VOID:
                    {
                    alt175=2;
                    }
                    break;
            }

            switch (alt175) {
                case 1 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1374:36: type
                    {
                    pushFollow(FOLLOW_type_in_methodHeader9607);
                    type660=type();

                    state._fsp--;
                    if (state.failed) return retval;
                    if ( state.backtracking==0 ) adaptor.addChild(root_0, type660.getTree());

                    }
                    break;
                case 2 :
                    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1374:41: 'void'
                    {
                    string_literal661=(Token)match(input,VOID,FOLLOW_VOID_in_methodHeader9609); if (state.failed) return retval;
                    if ( state.backtracking==0 ) {
                    string_literal661_tree = 
                    (Object)adaptor.create(string_literal661)
                    ;
                    adaptor.addChild(root_0, string_literal661_tree);
                    }

                    }
                    break;

            }


            IDENTIFIER662=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_methodHeader9613); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER662_tree = 
            (Object)adaptor.create(IDENTIFIER662)
            ;
            adaptor.addChild(root_0, IDENTIFIER662_tree);
            }

            char_literal663=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_methodHeader9615); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            char_literal663_tree = 
            (Object)adaptor.create(char_literal663)
            ;
            adaptor.addChild(root_0, char_literal663_tree);
            }

            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 110, methodHeader_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "methodHeader"


    public static class fieldHeader_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "fieldHeader"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1377:1: fieldHeader : modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ;
    public final JavaTreeParser.fieldHeader_return fieldHeader() throws RecognitionException {
        JavaTreeParser.fieldHeader_return retval = new JavaTreeParser.fieldHeader_return();
        retval.start = input.LT(1);

        int fieldHeader_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER666=null;
        Token char_literal667=null;
        Token char_literal668=null;
        Token set669=null;
        JavaTreeParser.modifiers_return modifiers664 =null;

        JavaTreeParser.type_return type665 =null;


        Object IDENTIFIER666_tree=null;
        Object char_literal667_tree=null;
        Object char_literal668_tree=null;
        Object set669_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 111) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1378:5: ( modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1378:9: modifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' )
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_modifiers_in_fieldHeader9635);
            modifiers664=modifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, modifiers664.getTree());

            pushFollow(FOLLOW_type_in_fieldHeader9637);
            type665=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, type665.getTree());

            IDENTIFIER666=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_fieldHeader9639); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER666_tree = 
            (Object)adaptor.create(IDENTIFIER666)
            ;
            adaptor.addChild(root_0, IDENTIFIER666_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1378:35: ( '[' ']' )*
            loop176:
            do {
                int alt176=2;
                int LA176_0 = input.LA(1);

                if ( (LA176_0==LBRACKET) ) {
                    alt176=1;
                }


                switch (alt176) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1378:36: '[' ']'
            	    {
            	    char_literal667=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_fieldHeader9642); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal667_tree = 
            	    (Object)adaptor.create(char_literal667)
            	    ;
            	    adaptor.addChild(root_0, char_literal667_tree);
            	    }

            	    char_literal668=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_fieldHeader9643); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal668_tree = 
            	    (Object)adaptor.create(char_literal668)
            	    ;
            	    adaptor.addChild(root_0, char_literal668_tree);
            	    }

            	    }
            	    break;

            	default :
            	    break loop176;
                }
            } while (true);


            set669=(Token)input.LT(1);

            if ( input.LA(1)==COMMA||input.LA(1)==EQ||input.LA(1)==SEMI ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                (Object)adaptor.create(set669)
                );
                state.errorRecovery=false;
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 111, fieldHeader_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "fieldHeader"


    public static class localVariableHeader_return extends ParserRuleReturnScope {
        Object tree;
        public Object getTree() { return tree; }
    };


    // $ANTLR start "localVariableHeader"
    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1381:1: localVariableHeader : variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) ;
    public final JavaTreeParser.localVariableHeader_return localVariableHeader() throws RecognitionException {
        JavaTreeParser.localVariableHeader_return retval = new JavaTreeParser.localVariableHeader_return();
        retval.start = input.LT(1);

        int localVariableHeader_StartIndex = input.index();

        Object root_0 = null;

        Token IDENTIFIER672=null;
        Token char_literal673=null;
        Token char_literal674=null;
        Token set675=null;
        JavaTreeParser.variableModifiers_return variableModifiers670 =null;

        JavaTreeParser.type_return type671 =null;


        Object IDENTIFIER672_tree=null;
        Object char_literal673_tree=null;
        Object char_literal674_tree=null;
        Object set675_tree=null;

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 112) ) { return retval; }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1382:5: ( variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' ) )
            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1382:9: variableModifiers type IDENTIFIER ( '[' ']' )* ( '=' | ',' | ';' )
            {
            root_0 = (Object)adaptor.nil();


            pushFollow(FOLLOW_variableModifiers_in_localVariableHeader9673);
            variableModifiers670=variableModifiers();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, variableModifiers670.getTree());

            pushFollow(FOLLOW_type_in_localVariableHeader9675);
            type671=type();

            state._fsp--;
            if (state.failed) return retval;
            if ( state.backtracking==0 ) adaptor.addChild(root_0, type671.getTree());

            IDENTIFIER672=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_localVariableHeader9677); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IDENTIFIER672_tree = 
            (Object)adaptor.create(IDENTIFIER672)
            ;
            adaptor.addChild(root_0, IDENTIFIER672_tree);
            }

            // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1382:43: ( '[' ']' )*
            loop177:
            do {
                int alt177=2;
                int LA177_0 = input.LA(1);

                if ( (LA177_0==LBRACKET) ) {
                    alt177=1;
                }


                switch (alt177) {
            	case 1 :
            	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1382:44: '[' ']'
            	    {
            	    char_literal673=(Token)match(input,LBRACKET,FOLLOW_LBRACKET_in_localVariableHeader9680); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal673_tree = 
            	    (Object)adaptor.create(char_literal673)
            	    ;
            	    adaptor.addChild(root_0, char_literal673_tree);
            	    }

            	    char_literal674=(Token)match(input,RBRACKET,FOLLOW_RBRACKET_in_localVariableHeader9681); if (state.failed) return retval;
            	    if ( state.backtracking==0 ) {
            	    char_literal674_tree = 
            	    (Object)adaptor.create(char_literal674)
            	    ;
            	    adaptor.addChild(root_0, char_literal674_tree);
            	    }

            	    }
            	    break;

            	default :
            	    break loop177;
                }
            } while (true);


            set675=(Token)input.LT(1);

            if ( input.LA(1)==COMMA||input.LA(1)==EQ||input.LA(1)==SEMI ) {
                input.consume();
                if ( state.backtracking==0 ) adaptor.addChild(root_0, 
                (Object)adaptor.create(set675)
                );
                state.errorRecovery=false;
                state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return retval;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                throw mse;
            }


            }

            retval.stop = input.LT(-1);


            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }

        finally {
        	// do for sure before leaving
            if ( state.backtracking>0 ) { memoize(input, 112, localVariableHeader_StartIndex); }

        }
        return retval;
    }
    // $ANTLR end "localVariableHeader"

    // $ANTLR start synpred2_JavaTree
    public final void synpred2_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:10: ( ( annotations )? packageDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:10: ( annotations )? packageDeclaration
        {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:10: ( annotations )?
        int alt178=2;
        int LA178_0 = input.LA(1);

        if ( (LA178_0==MONKEYS_AT) ) {
            alt178=1;
        }
        switch (alt178) {
            case 1 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:314:11: annotations
                {
                pushFollow(FOLLOW_annotations_in_synpred2_JavaTree169);
                annotations();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        pushFollow(FOLLOW_packageDeclaration_in_synpred2_JavaTree173);
        packageDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred2_JavaTree

    // $ANTLR start synpred12_JavaTree
    public final void synpred12_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:351:10: ( classDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:351:10: classDeclaration
        {
        pushFollow(FOLLOW_classDeclaration_in_synpred12_JavaTree513);
        classDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred12_JavaTree

    // $ANTLR start synpred27_JavaTree
    public final void synpred27_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:382:9: ( normalClassDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:382:9: normalClassDeclaration
        {
        pushFollow(FOLLOW_normalClassDeclaration_in_synpred27_JavaTree749);
        normalClassDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred27_JavaTree

    // $ANTLR start synpred43_JavaTree
    public final void synpred43_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:492:9: ( normalInterfaceDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:492:9: normalInterfaceDeclaration
        {
        pushFollow(FOLLOW_normalInterfaceDeclaration_in_synpred43_JavaTree1744);
        normalInterfaceDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred43_JavaTree

    // $ANTLR start synpred52_JavaTree
    public final void synpred52_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:544:10: ( fieldDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:544:10: fieldDeclaration
        {
        pushFollow(FOLLOW_fieldDeclaration_in_synpred52_JavaTree2224);
        fieldDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred52_JavaTree

    // $ANTLR start synpred53_JavaTree
    public final void synpred53_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:545:10: ( methodDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:545:10: methodDeclaration
        {
        pushFollow(FOLLOW_methodDeclaration_in_synpred53_JavaTree2235);
        methodDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred53_JavaTree

    // $ANTLR start synpred54_JavaTree
    public final void synpred54_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:546:10: ( classDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:546:10: classDeclaration
        {
        pushFollow(FOLLOW_classDeclaration_in_synpred54_JavaTree2246);
        classDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred54_JavaTree

    // $ANTLR start synpred57_JavaTree
    public final void synpred57_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:562:10: ( explicitConstructorInvocation )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:562:10: explicitConstructorInvocation
        {
        pushFollow(FOLLOW_explicitConstructorInvocation_in_synpred57_JavaTree2383);
        explicitConstructorInvocation();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred57_JavaTree

    // $ANTLR start synpred59_JavaTree
    public final void synpred59_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:554:10: ( modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}' )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:554:10: modifiers ( typeParameters )? IDENTIFIER formalParameters ( 'throws' qualifiedNameList )? '{' ( explicitConstructorInvocation )? ( blockStatement )* '}'
        {
        pushFollow(FOLLOW_modifiers_in_synpred59_JavaTree2295);
        modifiers();

        state._fsp--;
        if (state.failed) return ;

        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:555:9: ( typeParameters )?
        int alt181=2;
        int LA181_0 = input.LA(1);

        if ( (LA181_0==LT) ) {
            alt181=1;
        }
        switch (alt181) {
            case 1 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:555:10: typeParameters
                {
                pushFollow(FOLLOW_typeParameters_in_synpred59_JavaTree2306);
                typeParameters();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred59_JavaTree2327); if (state.failed) return ;

        pushFollow(FOLLOW_formalParameters_in_synpred59_JavaTree2337);
        formalParameters();

        state._fsp--;
        if (state.failed) return ;

        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:559:9: ( 'throws' qualifiedNameList )?
        int alt182=2;
        int LA182_0 = input.LA(1);

        if ( (LA182_0==THROWS) ) {
            alt182=1;
        }
        switch (alt182) {
            case 1 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:559:10: 'throws' qualifiedNameList
                {
                match(input,THROWS,FOLLOW_THROWS_in_synpred59_JavaTree2348); if (state.failed) return ;

                pushFollow(FOLLOW_qualifiedNameList_in_synpred59_JavaTree2350);
                qualifiedNameList();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        match(input,LBRACE,FOLLOW_LBRACE_in_synpred59_JavaTree2371); if (state.failed) return ;

        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:562:9: ( explicitConstructorInvocation )?
        int alt183=2;
        switch ( input.LA(1) ) {
            case LT:
                {
                alt183=1;
                }
                break;
            case THIS:
                {
                int LA183_2 = input.LA(2);

                if ( (synpred57_JavaTree()) ) {
                    alt183=1;
                }
                }
                break;
            case LPAREN:
                {
                int LA183_3 = input.LA(2);

                if ( (synpred57_JavaTree()) ) {
                    alt183=1;
                }
                }
                break;
            case SUPER:
                {
                int LA183_4 = input.LA(2);

                if ( (synpred57_JavaTree()) ) {
                    alt183=1;
                }
                }
                break;
            case IDENTIFIER:
                {
                int LA183_5 = input.LA(2);

                if ( (synpred57_JavaTree()) ) {
                    alt183=1;
                }
                }
                break;
            case CHARLITERAL:
            case DOUBLELITERAL:
            case FALSE:
            case FLOATLITERAL:
            case INTLITERAL:
            case LONGLITERAL:
            case NULL:
            case STRINGLITERAL:
            case TRUE:
                {
                int LA183_6 = input.LA(2);

                if ( (synpred57_JavaTree()) ) {
                    alt183=1;
                }
                }
                break;
            case NEW:
                {
                int LA183_7 = input.LA(2);

                if ( (synpred57_JavaTree()) ) {
                    alt183=1;
                }
                }
                break;
            case BOOLEAN:
            case BYTE:
            case CHAR:
            case DOUBLE:
            case FLOAT:
            case INT:
            case LONG:
            case SHORT:
                {
                int LA183_8 = input.LA(2);

                if ( (synpred57_JavaTree()) ) {
                    alt183=1;
                }
                }
                break;
            case VOID:
                {
                int LA183_9 = input.LA(2);

                if ( (synpred57_JavaTree()) ) {
                    alt183=1;
                }
                }
                break;
        }

        switch (alt183) {
            case 1 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:562:10: explicitConstructorInvocation
                {
                pushFollow(FOLLOW_explicitConstructorInvocation_in_synpred59_JavaTree2383);
                explicitConstructorInvocation();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:564:9: ( blockStatement )*
        loop184:
        do {
            int alt184=2;
            int LA184_0 = input.LA(1);

            if ( (LA184_0==ABSTRACT||(LA184_0 >= ASSERT && LA184_0 <= BANG)||(LA184_0 >= BOOLEAN && LA184_0 <= BYTE)||(LA184_0 >= CHAR && LA184_0 <= CLASS)||LA184_0==CONTINUE||LA184_0==DO||(LA184_0 >= DOUBLE && LA184_0 <= DOUBLELITERAL)||LA184_0==ENUM||LA184_0==FALSE||LA184_0==FINAL||(LA184_0 >= FLOAT && LA184_0 <= FOR)||(LA184_0 >= IDENTIFIER && LA184_0 <= IF)||(LA184_0 >= INT && LA184_0 <= INTLITERAL)||LA184_0==LBRACE||(LA184_0 >= LONG && LA184_0 <= LT)||LA184_0==MONKEYS_AT||(LA184_0 >= NATIVE && LA184_0 <= NEW)||LA184_0==NULL||LA184_0==PLUS||(LA184_0 >= PLUSPLUS && LA184_0 <= PUBLIC)||LA184_0==RETURN||(LA184_0 >= SEMI && LA184_0 <= SHORT)||(LA184_0 >= STATIC && LA184_0 <= SUB)||(LA184_0 >= SUBSUB && LA184_0 <= SYNCHRONIZED)||(LA184_0 >= THIS && LA184_0 <= THROW)||(LA184_0 >= TILDE && LA184_0 <= TRY)||(LA184_0 >= VOID && LA184_0 <= WHILE)) ) {
                alt184=1;
            }


            switch (alt184) {
        	case 1 :
        	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:564:10: blockStatement
        	    {
        	    pushFollow(FOLLOW_blockStatement_in_synpred59_JavaTree2405);
        	    blockStatement();

        	    state._fsp--;
        	    if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop184;
            }
        } while (true);


        match(input,RBRACE,FOLLOW_RBRACE_in_synpred59_JavaTree2426); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred59_JavaTree

    // $ANTLR start synpred64_JavaTree
    public final void synpred64_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:568:9: ( modifiers ( typeParameters )? type IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' ) )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:568:9: modifiers ( typeParameters )? type IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ( block | ';' )
        {
        pushFollow(FOLLOW_modifiers_in_synpred64_JavaTree2483);
        modifiers();

        state._fsp--;
        if (state.failed) return ;

        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:569:9: ( typeParameters )?
        int alt185=2;
        int LA185_0 = input.LA(1);

        if ( (LA185_0==LT) ) {
            alt185=1;
        }
        switch (alt185) {
            case 1 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:569:10: typeParameters
                {
                pushFollow(FOLLOW_typeParameters_in_synpred64_JavaTree2494);
                typeParameters();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        pushFollow(FOLLOW_type_in_synpred64_JavaTree2515);
        type();

        state._fsp--;
        if (state.failed) return ;

        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred64_JavaTree2525); if (state.failed) return ;

        pushFollow(FOLLOW_formalParameters_in_synpred64_JavaTree2535);
        formalParameters();

        state._fsp--;
        if (state.failed) return ;

        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:574:9: ( '[' ']' )*
        loop186:
        do {
            int alt186=2;
            int LA186_0 = input.LA(1);

            if ( (LA186_0==LBRACKET) ) {
                alt186=1;
            }


            switch (alt186) {
        	case 1 :
        	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:574:10: '[' ']'
        	    {
        	    match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred64_JavaTree2546); if (state.failed) return ;

        	    match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred64_JavaTree2548); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop186;
            }
        } while (true);


        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:576:9: ( 'throws' qualifiedNameList )?
        int alt187=2;
        int LA187_0 = input.LA(1);

        if ( (LA187_0==THROWS) ) {
            alt187=1;
        }
        switch (alt187) {
            case 1 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:576:10: 'throws' qualifiedNameList
                {
                match(input,THROWS,FOLLOW_THROWS_in_synpred64_JavaTree2570); if (state.failed) return ;

                pushFollow(FOLLOW_qualifiedNameList_in_synpred64_JavaTree2572);
                qualifiedNameList();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:578:9: ( block | ';' )
        int alt188=2;
        int LA188_0 = input.LA(1);

        if ( (LA188_0==LBRACE) ) {
            alt188=1;
        }
        else if ( (LA188_0==SEMI) ) {
            alt188=2;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            NoViableAltException nvae =
                new NoViableAltException("", 188, 0, input);

            throw nvae;

        }
        switch (alt188) {
            case 1 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:579:13: block
                {
                pushFollow(FOLLOW_block_in_synpred64_JavaTree2627);
                block();

                state._fsp--;
                if (state.failed) return ;

                }
                break;
            case 2 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:580:13: ';'
                {
                match(input,SEMI,FOLLOW_SEMI_in_synpred64_JavaTree2641); if (state.failed) return ;

                }
                break;

        }


        }

    }
    // $ANTLR end synpred64_JavaTree

    // $ANTLR start synpred72_JavaTree
    public final void synpred72_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:626:9: ( interfaceFieldDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:626:9: interfaceFieldDeclaration
        {
        pushFollow(FOLLOW_interfaceFieldDeclaration_in_synpred72_JavaTree3181);
        interfaceFieldDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred72_JavaTree

    // $ANTLR start synpred73_JavaTree
    public final void synpred73_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:627:9: ( interfaceMethodDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:627:9: interfaceMethodDeclaration
        {
        pushFollow(FOLLOW_interfaceMethodDeclaration_in_synpred73_JavaTree3191);
        interfaceMethodDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred73_JavaTree

    // $ANTLR start synpred74_JavaTree
    public final void synpred74_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:628:9: ( interfaceDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:628:9: interfaceDeclaration
        {
        pushFollow(FOLLOW_interfaceDeclaration_in_synpred74_JavaTree3201);
        interfaceDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred74_JavaTree

    // $ANTLR start synpred75_JavaTree
    public final void synpred75_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:629:9: ( classDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:629:9: classDeclaration
        {
        pushFollow(FOLLOW_classDeclaration_in_synpred75_JavaTree3211);
        classDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred75_JavaTree

    // $ANTLR start synpred79_JavaTree
    public final void synpred79_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:634:9: ( modifiers ( typeParameters )? 'void' IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';' )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:634:9: modifiers ( typeParameters )? 'void' IDENTIFIER formalParameters ( '[' ']' )* ( 'throws' qualifiedNameList )? ';'
        {
        pushFollow(FOLLOW_modifiers_in_synpred79_JavaTree3241);
        modifiers();

        state._fsp--;
        if (state.failed) return ;

        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:635:9: ( typeParameters )?
        int alt189=2;
        int LA189_0 = input.LA(1);

        if ( (LA189_0==LT) ) {
            alt189=1;
        }
        switch (alt189) {
            case 1 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:635:10: typeParameters
                {
                pushFollow(FOLLOW_typeParameters_in_synpred79_JavaTree3252);
                typeParameters();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        match(input,VOID,FOLLOW_VOID_in_synpred79_JavaTree3273); if (state.failed) return ;

        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred79_JavaTree3283); if (state.failed) return ;

        pushFollow(FOLLOW_formalParameters_in_synpred79_JavaTree3293);
        formalParameters();

        state._fsp--;
        if (state.failed) return ;

        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:640:9: ( '[' ']' )*
        loop190:
        do {
            int alt190=2;
            int LA190_0 = input.LA(1);

            if ( (LA190_0==LBRACKET) ) {
                alt190=1;
            }


            switch (alt190) {
        	case 1 :
        	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:640:10: '[' ']'
        	    {
        	    match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred79_JavaTree3304); if (state.failed) return ;

        	    match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred79_JavaTree3306); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop190;
            }
        } while (true);


        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:642:9: ( 'throws' qualifiedNameList )?
        int alt191=2;
        int LA191_0 = input.LA(1);

        if ( (LA191_0==THROWS) ) {
            alt191=1;
        }
        switch (alt191) {
            case 1 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:642:10: 'throws' qualifiedNameList
                {
                match(input,THROWS,FOLLOW_THROWS_in_synpred79_JavaTree3328); if (state.failed) return ;

                pushFollow(FOLLOW_qualifiedNameList_in_synpred79_JavaTree3330);
                qualifiedNameList();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        match(input,SEMI,FOLLOW_SEMI_in_synpred79_JavaTree3343); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred79_JavaTree

    // $ANTLR start synpred105_JavaTree
    public final void synpred105_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:742:9: ( ellipsisParameterDecl )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:742:9: ellipsisParameterDecl
        {
        pushFollow(FOLLOW_ellipsisParameterDecl_in_synpred105_JavaTree4342);
        ellipsisParameterDecl();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred105_JavaTree

    // $ANTLR start synpred107_JavaTree
    public final void synpred107_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:743:9: ( normalParameterDecl ( ',' normalParameterDecl )* )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:743:9: normalParameterDecl ( ',' normalParameterDecl )*
        {
        pushFollow(FOLLOW_normalParameterDecl_in_synpred107_JavaTree4360);
        normalParameterDecl();

        state._fsp--;
        if (state.failed) return ;

        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:744:9: ( ',' normalParameterDecl )*
        loop194:
        do {
            int alt194=2;
            int LA194_0 = input.LA(1);

            if ( (LA194_0==COMMA) ) {
                alt194=1;
            }


            switch (alt194) {
        	case 1 :
        	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:744:10: ',' normalParameterDecl
        	    {
        	    match(input,COMMA,FOLLOW_COMMA_in_synpred107_JavaTree4371); if (state.failed) return ;

        	    pushFollow(FOLLOW_normalParameterDecl_in_synpred107_JavaTree4373);
        	    normalParameterDecl();

        	    state._fsp--;
        	    if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop194;
            }
        } while (true);


        }

    }
    // $ANTLR end synpred107_JavaTree

    // $ANTLR start synpred108_JavaTree
    public final void synpred108_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:748:10: ( normalParameterDecl ',' )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:748:10: normalParameterDecl ','
        {
        pushFollow(FOLLOW_normalParameterDecl_in_synpred108_JavaTree4426);
        normalParameterDecl();

        state._fsp--;
        if (state.failed) return ;

        match(input,COMMA,FOLLOW_COMMA_in_synpred108_JavaTree4436); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred108_JavaTree

    // $ANTLR start synpred112_JavaTree
    public final void synpred112_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:772:9: ( ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';' )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:772:9: ( nonWildcardTypeArguments )? ( 'this' | 'super' ) arguments ';'
        {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:772:9: ( nonWildcardTypeArguments )?
        int alt195=2;
        int LA195_0 = input.LA(1);

        if ( (LA195_0==LT) ) {
            alt195=1;
        }
        switch (alt195) {
            case 1 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:772:10: nonWildcardTypeArguments
                {
                pushFollow(FOLLOW_nonWildcardTypeArguments_in_synpred112_JavaTree4636);
                nonWildcardTypeArguments();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        if ( input.LA(1)==SUPER||input.LA(1)==THIS ) {
            input.consume();
            state.errorRecovery=false;
            state.failed=false;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            MismatchedSetException mse = new MismatchedSetException(null,input);
            throw mse;
        }


        pushFollow(FOLLOW_arguments_in_synpred112_JavaTree4694);
        arguments();

        state._fsp--;
        if (state.failed) return ;

        match(input,SEMI,FOLLOW_SEMI_in_synpred112_JavaTree4696); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred112_JavaTree

    // $ANTLR start synpred126_JavaTree
    public final void synpred126_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:864:9: ( annotationMethodDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:864:9: annotationMethodDeclaration
        {
        pushFollow(FOLLOW_annotationMethodDeclaration_in_synpred126_JavaTree5366);
        annotationMethodDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred126_JavaTree

    // $ANTLR start synpred127_JavaTree
    public final void synpred127_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:865:9: ( interfaceFieldDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:865:9: interfaceFieldDeclaration
        {
        pushFollow(FOLLOW_interfaceFieldDeclaration_in_synpred127_JavaTree5376);
        interfaceFieldDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred127_JavaTree

    // $ANTLR start synpred128_JavaTree
    public final void synpred128_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:866:9: ( normalClassDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:866:9: normalClassDeclaration
        {
        pushFollow(FOLLOW_normalClassDeclaration_in_synpred128_JavaTree5386);
        normalClassDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred128_JavaTree

    // $ANTLR start synpred129_JavaTree
    public final void synpred129_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:867:9: ( normalInterfaceDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:867:9: normalInterfaceDeclaration
        {
        pushFollow(FOLLOW_normalInterfaceDeclaration_in_synpred129_JavaTree5396);
        normalInterfaceDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred129_JavaTree

    // $ANTLR start synpred130_JavaTree
    public final void synpred130_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:868:9: ( enumDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:868:9: enumDeclaration
        {
        pushFollow(FOLLOW_enumDeclaration_in_synpred130_JavaTree5406);
        enumDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred130_JavaTree

    // $ANTLR start synpred131_JavaTree
    public final void synpred131_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:869:9: ( annotationTypeDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:869:9: annotationTypeDeclaration
        {
        pushFollow(FOLLOW_annotationTypeDeclaration_in_synpred131_JavaTree5416);
        annotationTypeDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred131_JavaTree

    // $ANTLR start synpred134_JavaTree
    public final void synpred134_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:913:9: ( localVariableDeclarationStatement )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:913:9: localVariableDeclarationStatement
        {
        pushFollow(FOLLOW_localVariableDeclarationStatement_in_synpred134_JavaTree5592);
        localVariableDeclarationStatement();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred134_JavaTree

    // $ANTLR start synpred135_JavaTree
    public final void synpred135_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:914:9: ( classOrInterfaceDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:914:9: classOrInterfaceDeclaration
        {
        pushFollow(FOLLOW_classOrInterfaceDeclaration_in_synpred135_JavaTree5602);
        classOrInterfaceDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred135_JavaTree

    // $ANTLR start synpred139_JavaTree
    public final void synpred139_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:934:9: ( ( 'assert' ) expression ( ':' expression )? ';' )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:934:9: ( 'assert' ) expression ( ':' expression )? ';'
        {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:934:9: ( 'assert' )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:934:10: 'assert'
        {
        match(input,ASSERT,FOLLOW_ASSERT_in_synpred139_JavaTree5743); if (state.failed) return ;

        }


        pushFollow(FOLLOW_expression_in_synpred139_JavaTree5763);
        expression();

        state._fsp--;
        if (state.failed) return ;

        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:936:20: ( ':' expression )?
        int alt198=2;
        int LA198_0 = input.LA(1);

        if ( (LA198_0==COLON) ) {
            alt198=1;
        }
        switch (alt198) {
            case 1 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:936:21: ':' expression
                {
                match(input,COLON,FOLLOW_COLON_in_synpred139_JavaTree5766); if (state.failed) return ;

                pushFollow(FOLLOW_expression_in_synpred139_JavaTree5768);
                expression();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        match(input,SEMI,FOLLOW_SEMI_in_synpred139_JavaTree5772); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred139_JavaTree

    // $ANTLR start synpred141_JavaTree
    public final void synpred141_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:937:9: ( 'assert' expression ( ':' expression )? ';' )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:937:9: 'assert' expression ( ':' expression )? ';'
        {
        match(input,ASSERT,FOLLOW_ASSERT_in_synpred141_JavaTree5782); if (state.failed) return ;

        pushFollow(FOLLOW_expression_in_synpred141_JavaTree5785);
        expression();

        state._fsp--;
        if (state.failed) return ;

        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:937:30: ( ':' expression )?
        int alt199=2;
        int LA199_0 = input.LA(1);

        if ( (LA199_0==COLON) ) {
            alt199=1;
        }
        switch (alt199) {
            case 1 :
                // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:937:31: ':' expression
                {
                match(input,COLON,FOLLOW_COLON_in_synpred141_JavaTree5788); if (state.failed) return ;

                pushFollow(FOLLOW_expression_in_synpred141_JavaTree5790);
                expression();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }


        match(input,SEMI,FOLLOW_SEMI_in_synpred141_JavaTree5794); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred141_JavaTree

    // $ANTLR start synpred142_JavaTree
    public final void synpred142_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:938:39: ( 'else' statement )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:938:39: 'else' statement
        {
        match(input,ELSE,FOLLOW_ELSE_in_synpred142_JavaTree5823); if (state.failed) return ;

        pushFollow(FOLLOW_statement_in_synpred142_JavaTree5825);
        statement();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred142_JavaTree

    // $ANTLR start synpred157_JavaTree
    public final void synpred157_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:953:9: ( expression ';' )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:953:9: expression ';'
        {
        pushFollow(FOLLOW_expression_in_synpred157_JavaTree6047);
        expression();

        state._fsp--;
        if (state.failed) return ;

        match(input,SEMI,FOLLOW_SEMI_in_synpred157_JavaTree6050); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred157_JavaTree

    // $ANTLR start synpred158_JavaTree
    public final void synpred158_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:954:9: ( IDENTIFIER ':' statement )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:954:9: IDENTIFIER ':' statement
        {
        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred158_JavaTree6065); if (state.failed) return ;

        match(input,COLON,FOLLOW_COLON_in_synpred158_JavaTree6067); if (state.failed) return ;

        pushFollow(FOLLOW_statement_in_synpred158_JavaTree6069);
        statement();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred158_JavaTree

    // $ANTLR start synpred162_JavaTree
    public final void synpred162_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:977:13: ( catches 'finally' block )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:977:13: catches 'finally' block
        {
        pushFollow(FOLLOW_catches_in_synpred162_JavaTree6224);
        catches();

        state._fsp--;
        if (state.failed) return ;

        match(input,FINALLY,FOLLOW_FINALLY_in_synpred162_JavaTree6226); if (state.failed) return ;

        pushFollow(FOLLOW_block_in_synpred162_JavaTree6228);
        block();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred162_JavaTree

    // $ANTLR start synpred163_JavaTree
    public final void synpred163_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:978:13: ( catches )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:978:13: catches
        {
        pushFollow(FOLLOW_catches_in_synpred163_JavaTree6242);
        catches();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred163_JavaTree

    // $ANTLR start synpred165_JavaTree
    public final void synpred165_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:982:9: ( catches 'finally' block )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:982:9: catches 'finally' block
        {
        pushFollow(FOLLOW_catches_in_synpred165_JavaTree6292);
        catches();

        state._fsp--;
        if (state.failed) return ;

        match(input,FINALLY,FOLLOW_FINALLY_in_synpred165_JavaTree6294); if (state.failed) return ;

        pushFollow(FOLLOW_block_in_synpred165_JavaTree6296);
        block();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred165_JavaTree

    // $ANTLR start synpred166_JavaTree
    public final void synpred166_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:983:13: ( catches )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:983:13: catches
        {
        pushFollow(FOLLOW_catches_in_synpred166_JavaTree6310);
        catches();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred166_JavaTree

    // $ANTLR start synpred174_JavaTree
    public final void synpred174_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1020:9: ( 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1020:9: 'for' '(' variableModifiers type IDENTIFIER ':' expression ')' statement
        {
        match(input,FOR,FOLLOW_FOR_in_synpred174_JavaTree6587); if (state.failed) return ;

        match(input,LPAREN,FOLLOW_LPAREN_in_synpred174_JavaTree6589); if (state.failed) return ;

        pushFollow(FOLLOW_variableModifiers_in_synpred174_JavaTree6591);
        variableModifiers();

        state._fsp--;
        if (state.failed) return ;

        pushFollow(FOLLOW_type_in_synpred174_JavaTree6593);
        type();

        state._fsp--;
        if (state.failed) return ;

        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred174_JavaTree6595); if (state.failed) return ;

        match(input,COLON,FOLLOW_COLON_in_synpred174_JavaTree6597); if (state.failed) return ;

        pushFollow(FOLLOW_expression_in_synpred174_JavaTree6608);
        expression();

        state._fsp--;
        if (state.failed) return ;

        match(input,RPAREN,FOLLOW_RPAREN_in_synpred174_JavaTree6610); if (state.failed) return ;

        pushFollow(FOLLOW_statement_in_synpred174_JavaTree6612);
        statement();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred174_JavaTree

    // $ANTLR start synpred178_JavaTree
    public final void synpred178_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1034:9: ( localVariableDeclaration )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1034:9: localVariableDeclaration
        {
        pushFollow(FOLLOW_localVariableDeclaration_in_synpred178_JavaTree6791);
        localVariableDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred178_JavaTree

    // $ANTLR start synpred219_JavaTree
    public final void synpred219_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1188:9: ( castExpression )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1188:9: castExpression
        {
        pushFollow(FOLLOW_castExpression_in_synpred219_JavaTree8036);
        castExpression();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred219_JavaTree

    // $ANTLR start synpred223_JavaTree
    public final void synpred223_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1198:9: ( '(' primitiveType ')' unaryExpression )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1198:9: '(' primitiveType ')' unaryExpression
        {
        match(input,LPAREN,FOLLOW_LPAREN_in_synpred223_JavaTree8127); if (state.failed) return ;

        pushFollow(FOLLOW_primitiveType_in_synpred223_JavaTree8129);
        primitiveType();

        state._fsp--;
        if (state.failed) return ;

        match(input,RPAREN,FOLLOW_RPAREN_in_synpred223_JavaTree8131); if (state.failed) return ;

        pushFollow(FOLLOW_unaryExpression_in_synpred223_JavaTree8133);
        unaryExpression();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred223_JavaTree

    // $ANTLR start synpred225_JavaTree
    public final void synpred225_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1208:10: ( '.' IDENTIFIER )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1208:10: '.' IDENTIFIER
        {
        match(input,DOT,FOLLOW_DOT_in_synpred225_JavaTree8204); if (state.failed) return ;

        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred225_JavaTree8206); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred225_JavaTree

    // $ANTLR start synpred226_JavaTree
    public final void synpred226_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1210:10: ( identifierSuffix )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1210:10: identifierSuffix
        {
        pushFollow(FOLLOW_identifierSuffix_in_synpred226_JavaTree8228);
        identifierSuffix();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred226_JavaTree

    // $ANTLR start synpred228_JavaTree
    public final void synpred228_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1213:10: ( '.' IDENTIFIER )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1213:10: '.' IDENTIFIER
        {
        match(input,DOT,FOLLOW_DOT_in_synpred228_JavaTree8260); if (state.failed) return ;

        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred228_JavaTree8262); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred228_JavaTree

    // $ANTLR start synpred229_JavaTree
    public final void synpred229_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1215:10: ( identifierSuffix )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1215:10: identifierSuffix
        {
        pushFollow(FOLLOW_identifierSuffix_in_synpred229_JavaTree8284);
        identifierSuffix();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred229_JavaTree

    // $ANTLR start synpred241_JavaTree
    public final void synpred241_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1243:10: ( '[' expression ']' )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1243:10: '[' expression ']'
        {
        match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred241_JavaTree8535); if (state.failed) return ;

        pushFollow(FOLLOW_expression_in_synpred241_JavaTree8537);
        expression();

        state._fsp--;
        if (state.failed) return ;

        match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred241_JavaTree8539); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred241_JavaTree

    // $ANTLR start synpred253_JavaTree
    public final void synpred253_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1266:9: ( 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1266:9: 'new' nonWildcardTypeArguments classOrInterfaceType classCreatorRest
        {
        match(input,NEW,FOLLOW_NEW_in_synpred253_JavaTree8748); if (state.failed) return ;

        pushFollow(FOLLOW_nonWildcardTypeArguments_in_synpred253_JavaTree8750);
        nonWildcardTypeArguments();

        state._fsp--;
        if (state.failed) return ;

        pushFollow(FOLLOW_classOrInterfaceType_in_synpred253_JavaTree8752);
        classOrInterfaceType();

        state._fsp--;
        if (state.failed) return ;

        pushFollow(FOLLOW_classCreatorRest_in_synpred253_JavaTree8754);
        classCreatorRest();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred253_JavaTree

    // $ANTLR start synpred254_JavaTree
    public final void synpred254_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1267:9: ( 'new' classOrInterfaceType classCreatorRest )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1267:9: 'new' classOrInterfaceType classCreatorRest
        {
        match(input,NEW,FOLLOW_NEW_in_synpred254_JavaTree8764); if (state.failed) return ;

        pushFollow(FOLLOW_classOrInterfaceType_in_synpred254_JavaTree8766);
        classOrInterfaceType();

        state._fsp--;
        if (state.failed) return ;

        pushFollow(FOLLOW_classCreatorRest_in_synpred254_JavaTree8768);
        classCreatorRest();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred254_JavaTree

    // $ANTLR start synpred256_JavaTree
    public final void synpred256_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1272:9: ( 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1272:9: 'new' createdName '[' ']' ( '[' ']' )* arrayInitializer
        {
        match(input,NEW,FOLLOW_NEW_in_synpred256_JavaTree8798); if (state.failed) return ;

        pushFollow(FOLLOW_createdName_in_synpred256_JavaTree8800);
        createdName();

        state._fsp--;
        if (state.failed) return ;

        match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred256_JavaTree8810); if (state.failed) return ;

        match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred256_JavaTree8812); if (state.failed) return ;

        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1274:9: ( '[' ']' )*
        loop213:
        do {
            int alt213=2;
            int LA213_0 = input.LA(1);

            if ( (LA213_0==LBRACKET) ) {
                alt213=1;
            }


            switch (alt213) {
        	case 1 :
        	    // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1274:10: '[' ']'
        	    {
        	    match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred256_JavaTree8823); if (state.failed) return ;

        	    match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred256_JavaTree8825); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop213;
            }
        } while (true);


        pushFollow(FOLLOW_arrayInitializer_in_synpred256_JavaTree8846);
        arrayInitializer();

        state._fsp--;
        if (state.failed) return ;

        }

    }
    // $ANTLR end synpred256_JavaTree

    // $ANTLR start synpred257_JavaTree
    public final void synpred257_JavaTree_fragment() throws RecognitionException {
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1281:13: ( '[' expression ']' )
        // D:\\My Documents\\Java\\NewCrunch\\src\\main\\resources\\newcrunch\\parser\\JavaTree.g:1281:13: '[' expression ']'
        {
        match(input,LBRACKET,FOLLOW_LBRACKET_in_synpred257_JavaTree8895); if (state.failed) return ;

        pushFollow(FOLLOW_expression_in_synpred257_JavaTree8897);
        expression();

        state._fsp--;
        if (state.failed) return ;

        match(input,RBRACKET,FOLLOW_RBRACKET_in_synpred257_JavaTree8911); if (state.failed) return ;

        }

    }
    // $ANTLR end synpred257_JavaTree

    // Delegated rules

    public final boolean synpred134_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred134_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred54_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred54_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred228_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred228_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred108_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred108_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred52_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred52_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred129_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred129_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred79_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred79_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred27_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred27_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred142_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred142_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred256_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred256_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred257_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred257_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred157_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred157_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred57_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred57_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred178_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred178_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred59_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred59_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred241_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred241_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred72_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred72_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred127_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred127_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred126_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred126_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred2_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred2_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred139_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred139_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred254_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred254_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred43_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred43_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred158_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred158_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred162_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred162_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred141_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred141_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred174_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred174_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred131_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred131_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred135_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred135_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred166_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred166_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred73_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred73_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred107_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred107_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred105_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred105_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred53_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred53_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred130_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred130_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred12_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred12_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred223_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred223_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred226_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred226_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred74_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred74_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred128_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred128_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred75_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred75_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred229_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred229_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred225_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred225_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred165_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred165_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred163_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred163_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred253_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred253_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred64_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred64_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred219_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred219_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred112_JavaTree() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred112_JavaTree_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }


 

    public static final BitSet FOLLOW_annotations_in_compilationUnit169 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_packageDeclaration_in_compilationUnit173 = new BitSet(new long[]{0x0040100008000012L,0x103040E002800120L,0x0000000000000204L});
    public static final BitSet FOLLOW_importDeclaration_in_compilationUnit178 = new BitSet(new long[]{0x0040100008000012L,0x103040E002800120L,0x0000000000000204L});
    public static final BitSet FOLLOW_typeDeclaration_in_compilationUnit183 = new BitSet(new long[]{0x0040100008000012L,0x103040E002800100L,0x0000000000000204L});
    public static final BitSet FOLLOW_PACKAGE_in_packageDeclaration237 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_qualifiedName_in_packageDeclaration239 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_packageDeclaration241 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IMPORT_in_importDeclaration263 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000004L});
    public static final BitSet FOLLOW_STATIC_in_importDeclaration275 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration296 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_DOT_in_importDeclaration298 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L});
    public static final BitSet FOLLOW_STAR_in_importDeclaration300 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_importDeclaration310 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IMPORT_in_importDeclaration327 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000004L});
    public static final BitSet FOLLOW_STATIC_in_importDeclaration339 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration360 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_DOT_in_importDeclaration371 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_importDeclaration373 = new BitSet(new long[]{0x0000001000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_DOT_in_importDeclaration395 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L});
    public static final BitSet FOLLOW_STAR_in_importDeclaration397 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_importDeclaration418 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedImportName438 = new BitSet(new long[]{0x0000001000000002L});
    public static final BitSet FOLLOW_DOT_in_qualifiedImportName449 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedImportName451 = new BitSet(new long[]{0x0000001000000002L});
    public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_typeDeclaration482 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_typeDeclaration492 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_classOrInterfaceDeclaration513 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceDeclaration_in_classOrInterfaceDeclaration523 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotation_in_modifiers557 = new BitSet(new long[]{0x0040000000000012L,0x103000E002800000L,0x0000000000000204L});
    public static final BitSet FOLLOW_PUBLIC_in_modifiers567 = new BitSet(new long[]{0x0040000000000012L,0x103000E002800000L,0x0000000000000204L});
    public static final BitSet FOLLOW_PROTECTED_in_modifiers577 = new BitSet(new long[]{0x0040000000000012L,0x103000E002800000L,0x0000000000000204L});
    public static final BitSet FOLLOW_PRIVATE_in_modifiers587 = new BitSet(new long[]{0x0040000000000012L,0x103000E002800000L,0x0000000000000204L});
    public static final BitSet FOLLOW_STATIC_in_modifiers597 = new BitSet(new long[]{0x0040000000000012L,0x103000E002800000L,0x0000000000000204L});
    public static final BitSet FOLLOW_ABSTRACT_in_modifiers607 = new BitSet(new long[]{0x0040000000000012L,0x103000E002800000L,0x0000000000000204L});
    public static final BitSet FOLLOW_FINAL_in_modifiers617 = new BitSet(new long[]{0x0040000000000012L,0x103000E002800000L,0x0000000000000204L});
    public static final BitSet FOLLOW_NATIVE_in_modifiers627 = new BitSet(new long[]{0x0040000000000012L,0x103000E002800000L,0x0000000000000204L});
    public static final BitSet FOLLOW_SYNCHRONIZED_in_modifiers637 = new BitSet(new long[]{0x0040000000000012L,0x103000E002800000L,0x0000000000000204L});
    public static final BitSet FOLLOW_TRANSIENT_in_modifiers647 = new BitSet(new long[]{0x0040000000000012L,0x103000E002800000L,0x0000000000000204L});
    public static final BitSet FOLLOW_VOLATILE_in_modifiers657 = new BitSet(new long[]{0x0040000000000012L,0x103000E002800000L,0x0000000000000204L});
    public static final BitSet FOLLOW_STRICTFP_in_modifiers667 = new BitSet(new long[]{0x0040000000000012L,0x103000E002800000L,0x0000000000000204L});
    public static final BitSet FOLLOW_FINAL_in_variableModifiers699 = new BitSet(new long[]{0x0040000000000002L,0x0000000000800000L});
    public static final BitSet FOLLOW_annotation_in_variableModifiers713 = new BitSet(new long[]{0x0040000000000002L,0x0000000000800000L});
    public static final BitSet FOLLOW_normalClassDeclaration_in_classDeclaration749 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enumDeclaration_in_classDeclaration759 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_normalClassDeclaration779 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_CLASS_in_normalClassDeclaration782 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_normalClassDeclaration784 = new BitSet(new long[]{0x0002000000000000L,0x0000000000082010L});
    public static final BitSet FOLLOW_typeParameters_in_normalClassDeclaration795 = new BitSet(new long[]{0x0002000000000000L,0x0000000000002010L});
    public static final BitSet FOLLOW_EXTENDS_in_normalClassDeclaration817 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_normalClassDeclaration819 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002010L});
    public static final BitSet FOLLOW_IMPLEMENTS_in_normalClassDeclaration841 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_typeList_in_normalClassDeclaration843 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_classBody_in_normalClassDeclaration876 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LT_in_typeParameters1023 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_typeParameter_in_typeParameters1037 = new BitSet(new long[]{0x4000000040000000L});
    public static final BitSet FOLLOW_COMMA_in_typeParameters1052 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_typeParameter_in_typeParameters1054 = new BitSet(new long[]{0x4000000040000000L});
    public static final BitSet FOLLOW_GT_in_typeParameters1079 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_typeParameter1114 = new BitSet(new long[]{0x0002000000000002L});
    public static final BitSet FOLLOW_EXTENDS_in_typeParameter1125 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_typeBound_in_typeParameter1127 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_typeBound1186 = new BitSet(new long[]{0x0000000000000022L});
    public static final BitSet FOLLOW_AMP_in_typeBound1197 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_typeBound1199 = new BitSet(new long[]{0x0000000000000022L});
    public static final BitSet FOLLOW_modifiers_in_enumDeclaration1231 = new BitSet(new long[]{0x0000100000000000L});
    public static final BitSet FOLLOW_ENUM_in_enumDeclaration1243 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_enumDeclaration1264 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002010L});
    public static final BitSet FOLLOW_IMPLEMENTS_in_enumDeclaration1275 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_typeList_in_enumDeclaration1277 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_enumBody_in_enumDeclaration1298 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACE_in_enumBody1375 = new BitSet(new long[]{0x0000000040000000L,0x0000420000800004L});
    public static final BitSet FOLLOW_enumConstants_in_enumBody1386 = new BitSet(new long[]{0x0000000040000000L,0x0000420000000000L});
    public static final BitSet FOLLOW_COMMA_in_enumBody1408 = new BitSet(new long[]{0x0000000000000000L,0x0000420000000000L});
    public static final BitSet FOLLOW_enumBodyDeclarations_in_enumBody1421 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L});
    public static final BitSet FOLLOW_RBRACE_in_enumBody1443 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enumConstant_in_enumConstants1503 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_COMMA_in_enumConstants1514 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800004L});
    public static final BitSet FOLLOW_enumConstant_in_enumConstants1516 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_annotations_in_enumConstant1565 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_enumConstant1586 = new BitSet(new long[]{0x0000000000000002L,0x0000000000042000L});
    public static final BitSet FOLLOW_arguments_in_enumConstant1597 = new BitSet(new long[]{0x0000000000000002L,0x0000000000002000L});
    public static final BitSet FOLLOW_classBody_in_enumConstant1619 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_enumBodyDeclarations1680 = new BitSet(new long[]{0x014010200A050012L,0x1030C0E002892184L,0x0000000000000304L});
    public static final BitSet FOLLOW_classBodyDeclaration_in_enumBodyDeclarations1692 = new BitSet(new long[]{0x014010200A050012L,0x1030C0E002892184L,0x0000000000000304L});
    public static final BitSet FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration1744 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationTypeDeclaration_in_interfaceDeclaration1754 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_normalInterfaceDeclaration1778 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_INTERFACE_in_normalInterfaceDeclaration1780 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_normalInterfaceDeclaration1782 = new BitSet(new long[]{0x0002000000000000L,0x0000000000082000L});
    public static final BitSet FOLLOW_typeParameters_in_normalInterfaceDeclaration1793 = new BitSet(new long[]{0x0002000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_EXTENDS_in_normalInterfaceDeclaration1815 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_typeList_in_normalInterfaceDeclaration1817 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_interfaceBody_in_normalInterfaceDeclaration1838 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_typeList1941 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_COMMA_in_typeList1952 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_typeList1954 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_LBRACE_in_classBody2008 = new BitSet(new long[]{0x014010200A050010L,0x1030C2E002892184L,0x0000000000000304L});
    public static final BitSet FOLLOW_classBodyDeclaration_in_classBody2020 = new BitSet(new long[]{0x014010200A050010L,0x1030C2E002892184L,0x0000000000000304L});
    public static final BitSet FOLLOW_RBRACE_in_classBody2042 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACE_in_interfaceBody2087 = new BitSet(new long[]{0x014010200A050010L,0x1030C2E002890184L,0x0000000000000304L});
    public static final BitSet FOLLOW_interfaceBodyDeclaration_in_interfaceBody2099 = new BitSet(new long[]{0x014010200A050010L,0x1030C2E002890184L,0x0000000000000304L});
    public static final BitSet FOLLOW_RBRACE_in_interfaceBody2121 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_classBodyDeclaration2154 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STATIC_in_classBodyDeclaration2168 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_block_in_classBodyDeclaration2190 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_memberDecl_in_classBodyDeclaration2203 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fieldDeclaration_in_memberDecl2224 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_methodDeclaration_in_memberDecl2235 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_memberDecl2246 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceDeclaration_in_memberDecl2257 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_methodDeclaration2295 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080004L});
    public static final BitSet FOLLOW_typeParameters_in_methodDeclaration2306 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_methodDeclaration2327 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_formalParameters_in_methodDeclaration2337 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L,0x0000000000000001L});
    public static final BitSet FOLLOW_THROWS_in_methodDeclaration2348 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_qualifiedNameList_in_methodDeclaration2350 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_LBRACE_in_methodDeclaration2371 = new BitSet(new long[]{0x0750106A0E070C10L,0xDEF0CAF4168F238CL,0x000000000000071EL});
    public static final BitSet FOLLOW_explicitConstructorInvocation_in_methodDeclaration2383 = new BitSet(new long[]{0x0750106A0E070C10L,0xDEF0CAF41687238CL,0x000000000000071EL});
    public static final BitSet FOLLOW_blockStatement_in_methodDeclaration2405 = new BitSet(new long[]{0x0750106A0E070C10L,0xDEF0CAF41687238CL,0x000000000000071EL});
    public static final BitSet FOLLOW_RBRACE_in_methodDeclaration2426 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_methodDeclaration2483 = new BitSet(new long[]{0x0100002002050000L,0x0000800000090084L});
    public static final BitSet FOLLOW_typeParameters_in_methodDeclaration2494 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_methodDeclaration2515 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_methodDeclaration2525 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_formalParameters_in_methodDeclaration2535 = new BitSet(new long[]{0x0000000000000000L,0x0000400000006000L,0x0000000000000001L});
    public static final BitSet FOLLOW_LBRACKET_in_methodDeclaration2546 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_methodDeclaration2548 = new BitSet(new long[]{0x0000000000000000L,0x0000400000006000L,0x0000000000000001L});
    public static final BitSet FOLLOW_THROWS_in_methodDeclaration2570 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_qualifiedNameList_in_methodDeclaration2572 = new BitSet(new long[]{0x0000000000000000L,0x0000400000002000L});
    public static final BitSet FOLLOW_block_in_methodDeclaration2627 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_methodDeclaration2641 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_methodDeclaration2722 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L,0x0000000000000100L});
    public static final BitSet FOLLOW_typeParameters_in_methodDeclaration2733 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_VOID_in_methodDeclaration2754 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_methodDeclaration2764 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_formalParameters_in_methodDeclaration2774 = new BitSet(new long[]{0x0000000000000000L,0x0000400000006000L,0x0000000000000001L});
    public static final BitSet FOLLOW_LBRACKET_in_methodDeclaration2785 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_methodDeclaration2787 = new BitSet(new long[]{0x0000000000000000L,0x0000400000006000L,0x0000000000000001L});
    public static final BitSet FOLLOW_THROWS_in_methodDeclaration2809 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_qualifiedNameList_in_methodDeclaration2811 = new BitSet(new long[]{0x0000000000000000L,0x0000400000002000L});
    public static final BitSet FOLLOW_block_in_methodDeclaration2866 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_methodDeclaration2880 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_fieldDeclaration2972 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_fieldDeclaration2982 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_variableDeclarator_in_fieldDeclaration2992 = new BitSet(new long[]{0x0000000040000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_COMMA_in_fieldDeclaration3003 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_variableDeclarator_in_fieldDeclaration3005 = new BitSet(new long[]{0x0000000040000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_fieldDeclaration3026 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_variableDeclarator3078 = new BitSet(new long[]{0x0000800000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_variableDeclarator3089 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_variableDeclarator3091 = new BitSet(new long[]{0x0000800000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_EQ_in_variableDeclarator3113 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414072284L,0x000000000000010AL});
    public static final BitSet FOLLOW_variableInitializer_in_variableDeclarator3115 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFieldDeclaration_in_interfaceBodyDeclaration3181 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceMethodDeclaration_in_interfaceBodyDeclaration3191 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceDeclaration_in_interfaceBodyDeclaration3201 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_interfaceBodyDeclaration3211 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_interfaceBodyDeclaration3221 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_interfaceMethodDeclaration3241 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L,0x0000000000000100L});
    public static final BitSet FOLLOW_typeParameters_in_interfaceMethodDeclaration3252 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_VOID_in_interfaceMethodDeclaration3273 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration3283 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_formalParameters_in_interfaceMethodDeclaration3293 = new BitSet(new long[]{0x0000000000000000L,0x0000400000004000L,0x0000000000000001L});
    public static final BitSet FOLLOW_LBRACKET_in_interfaceMethodDeclaration3304 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_interfaceMethodDeclaration3306 = new BitSet(new long[]{0x0000000000000000L,0x0000400000004000L,0x0000000000000001L});
    public static final BitSet FOLLOW_THROWS_in_interfaceMethodDeclaration3328 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration3330 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_interfaceMethodDeclaration3343 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_interfaceMethodDeclaration3423 = new BitSet(new long[]{0x0100002002050000L,0x0000800000090084L});
    public static final BitSet FOLLOW_typeParameters_in_interfaceMethodDeclaration3434 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_interfaceMethodDeclaration3455 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_interfaceMethodDeclaration3465 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_formalParameters_in_interfaceMethodDeclaration3475 = new BitSet(new long[]{0x0000000000000000L,0x0000400000004000L,0x0000000000000001L});
    public static final BitSet FOLLOW_LBRACKET_in_interfaceMethodDeclaration3486 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_interfaceMethodDeclaration3488 = new BitSet(new long[]{0x0000000000000000L,0x0000400000004000L,0x0000000000000001L});
    public static final BitSet FOLLOW_THROWS_in_interfaceMethodDeclaration3510 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_qualifiedNameList_in_interfaceMethodDeclaration3512 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_interfaceMethodDeclaration3525 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_interfaceFieldDeclaration3606 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_interfaceFieldDeclaration3608 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_variableDeclarator_in_interfaceFieldDeclaration3610 = new BitSet(new long[]{0x0000000040000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_COMMA_in_interfaceFieldDeclaration3621 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_variableDeclarator_in_interfaceFieldDeclaration3623 = new BitSet(new long[]{0x0000000040000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_interfaceFieldDeclaration3644 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classOrInterfaceType_in_type3705 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_type3716 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_type3718 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_primitiveType_in_type3762 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_type3773 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_type3775 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_IDENTIFIER_in_classOrInterfaceType3830 = new BitSet(new long[]{0x0000001000000002L,0x0000000000080000L});
    public static final BitSet FOLLOW_typeArguments_in_classOrInterfaceType3841 = new BitSet(new long[]{0x0000001000000002L});
    public static final BitSet FOLLOW_LT_in_classOrInterfaceType3845 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_GT_in_classOrInterfaceType3847 = new BitSet(new long[]{0x0000001000000002L});
    public static final BitSet FOLLOW_DOT_in_classOrInterfaceType3869 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_classOrInterfaceType3871 = new BitSet(new long[]{0x0000001000000002L,0x0000000000080000L});
    public static final BitSet FOLLOW_typeArguments_in_classOrInterfaceType3886 = new BitSet(new long[]{0x0000001000000002L});
    public static final BitSet FOLLOW_LT_in_classOrInterfaceType3890 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_GT_in_classOrInterfaceType3892 = new BitSet(new long[]{0x0000001000000002L});
    public static final BitSet FOLLOW_LT_in_typeArguments4029 = new BitSet(new long[]{0x0100002002050000L,0x0000810000010084L});
    public static final BitSet FOLLOW_typeArgument_in_typeArguments4031 = new BitSet(new long[]{0x4000000040000000L});
    public static final BitSet FOLLOW_COMMA_in_typeArguments4042 = new BitSet(new long[]{0x0100002002050000L,0x0000810000010084L});
    public static final BitSet FOLLOW_typeArgument_in_typeArguments4044 = new BitSet(new long[]{0x4000000040000000L});
    public static final BitSet FOLLOW_GT_in_typeArguments4066 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_type_in_typeArgument4105 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_QUES_in_typeArgument4115 = new BitSet(new long[]{0x0002000000000002L,0x0400000000000000L});
    public static final BitSet FOLLOW_set_in_typeArgument4139 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_typeArgument4183 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedName_in_qualifiedNameList4214 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_COMMA_in_qualifiedNameList4225 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_qualifiedName_in_qualifiedNameList4227 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_LPAREN_in_formalParameters4289 = new BitSet(new long[]{0x0140002002050000L,0x0000A00000810084L});
    public static final BitSet FOLLOW_formalParameterDecls_in_formalParameters4300 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_formalParameters4322 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ellipsisParameterDecl_in_formalParameterDecls4342 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls4360 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_COMMA_in_formalParameterDecls4371 = new BitSet(new long[]{0x0140002002050000L,0x0000800000810084L});
    public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls4373 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_normalParameterDecl_in_formalParameterDecls4426 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_COMMA_in_formalParameterDecls4436 = new BitSet(new long[]{0x0140002002050000L,0x0000800000810084L});
    public static final BitSet FOLLOW_ellipsisParameterDecl_in_formalParameterDecls4458 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableModifiers_in_normalParameterDecl4510 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_normalParameterDecl4512 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_normalParameterDecl4514 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_normalParameterDecl4525 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_normalParameterDecl4527 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_variableModifiers_in_ellipsisParameterDecl4591 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_ellipsisParameterDecl4601 = new BitSet(new long[]{0x0000020000000000L});
    public static final BitSet FOLLOW_ELLIPSIS_in_ellipsisParameterDecl4604 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_ellipsisParameterDecl4614 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation4636 = new BitSet(new long[]{0x0000000000000000L,0x4400000000000000L});
    public static final BitSet FOLLOW_set_in_explicitConstructorInvocation4662 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_arguments_in_explicitConstructorInvocation4694 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_explicitConstructorInvocation4696 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primary_in_explicitConstructorInvocation4707 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_DOT_in_explicitConstructorInvocation4717 = new BitSet(new long[]{0x0000000000000000L,0x0400000000080000L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_explicitConstructorInvocation4728 = new BitSet(new long[]{0x0000000000000000L,0x0400000000000000L});
    public static final BitSet FOLLOW_SUPER_in_explicitConstructorInvocation4749 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_arguments_in_explicitConstructorInvocation4759 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_explicitConstructorInvocation4761 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedName4781 = new BitSet(new long[]{0x0000001000000002L});
    public static final BitSet FOLLOW_DOT_in_qualifiedName4792 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_qualifiedName4794 = new BitSet(new long[]{0x0000001000000002L});
    public static final BitSet FOLLOW_annotation_in_annotations4826 = new BitSet(new long[]{0x0000000000000002L,0x0000000000800000L});
    public static final BitSet FOLLOW_MONKEYS_AT_in_annotation4859 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_qualifiedName_in_annotation4861 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
    public static final BitSet FOLLOW_LPAREN_in_annotation4875 = new BitSet(new long[]{0x0310006006050800L,0x46C0A01414872284L,0x000000000000010AL});
    public static final BitSet FOLLOW_elementValuePairs_in_annotation4902 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_elementValue_in_annotation4926 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_annotation4962 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_elementValuePair_in_elementValuePairs5005 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_COMMA_in_elementValuePairs5016 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_elementValuePair_in_elementValuePairs5018 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_elementValuePair5049 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_EQ_in_elementValuePair5051 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414872284L,0x000000000000010AL});
    public static final BitSet FOLLOW_elementValue_in_elementValuePair5053 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalExpression_in_elementValue5073 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotation_in_elementValue5083 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_elementValueArrayInitializer_in_elementValue5093 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACE_in_elementValueArrayInitializer5113 = new BitSet(new long[]{0x0310006046050800L,0x46C0821414872284L,0x000000000000010AL});
    public static final BitSet FOLLOW_elementValue_in_elementValueArrayInitializer5124 = new BitSet(new long[]{0x0000000040000000L,0x0000020000000000L});
    public static final BitSet FOLLOW_COMMA_in_elementValueArrayInitializer5139 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414872284L,0x000000000000010AL});
    public static final BitSet FOLLOW_elementValue_in_elementValueArrayInitializer5141 = new BitSet(new long[]{0x0000000040000000L,0x0000020000000000L});
    public static final BitSet FOLLOW_COMMA_in_elementValueArrayInitializer5170 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L});
    public static final BitSet FOLLOW_RBRACE_in_elementValueArrayInitializer5174 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_annotationTypeDeclaration5197 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});
    public static final BitSet FOLLOW_MONKEYS_AT_in_annotationTypeDeclaration5199 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_INTERFACE_in_annotationTypeDeclaration5209 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_annotationTypeDeclaration5219 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_annotationTypeBody_in_annotationTypeDeclaration5229 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACE_in_annotationTypeBody5288 = new BitSet(new long[]{0x014010200A050010L,0x1030C2E002810184L,0x0000000000000204L});
    public static final BitSet FOLLOW_annotationTypeElementDeclaration_in_annotationTypeBody5300 = new BitSet(new long[]{0x014010200A050010L,0x1030C2E002810184L,0x0000000000000204L});
    public static final BitSet FOLLOW_RBRACE_in_annotationTypeBody5322 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationMethodDeclaration_in_annotationTypeElementDeclaration5366 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFieldDeclaration_in_annotationTypeElementDeclaration5376 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalClassDeclaration_in_annotationTypeElementDeclaration5386 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalInterfaceDeclaration_in_annotationTypeElementDeclaration5396 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enumDeclaration_in_annotationTypeElementDeclaration5406 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationTypeDeclaration_in_annotationTypeElementDeclaration5416 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_annotationTypeElementDeclaration5426 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_annotationMethodDeclaration5446 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_annotationMethodDeclaration5448 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_annotationMethodDeclaration5450 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_LPAREN_in_annotationMethodDeclaration5460 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_annotationMethodDeclaration5462 = new BitSet(new long[]{0x0000000400000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_DEFAULT_in_annotationMethodDeclaration5465 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414872284L,0x000000000000010AL});
    public static final BitSet FOLLOW_elementValue_in_annotationMethodDeclaration5467 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_annotationMethodDeclaration5496 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACE_in_block5538 = new BitSet(new long[]{0x0750106A0E070C10L,0xDEF0CAF41687238CL,0x000000000000071EL});
    public static final BitSet FOLLOW_blockStatement_in_block5549 = new BitSet(new long[]{0x0750106A0E070C10L,0xDEF0CAF41687238CL,0x000000000000071EL});
    public static final BitSet FOLLOW_RBRACE_in_block5570 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localVariableDeclarationStatement_in_blockStatement5592 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_blockStatement5602 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_blockStatement5612 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localVariableDeclaration_in_localVariableDeclarationStatement5633 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_localVariableDeclarationStatement5643 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableModifiers_in_localVariableDeclaration5663 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_localVariableDeclaration5665 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_variableDeclarator_in_localVariableDeclaration5675 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_COMMA_in_localVariableDeclaration5686 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_variableDeclarator_in_localVariableDeclaration5688 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_block_in_statement5719 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSERT_in_statement5743 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_statement5763 = new BitSet(new long[]{0x0000000020000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_COLON_in_statement5766 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_statement5768 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5772 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSERT_in_statement5782 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_statement5785 = new BitSet(new long[]{0x0000000020000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_COLON_in_statement5788 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_statement5790 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5794 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IF_in_statement5816 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_parExpression_in_statement5818 = new BitSet(new long[]{0x0710006A06070C00L,0xDEC0C8141407228CL,0x000000000000051AL});
    public static final BitSet FOLLOW_statement_in_statement5820 = new BitSet(new long[]{0x0000080000000002L});
    public static final BitSet FOLLOW_ELSE_in_statement5823 = new BitSet(new long[]{0x0710006A06070C00L,0xDEC0C8141407228CL,0x000000000000051AL});
    public static final BitSet FOLLOW_statement_in_statement5825 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forstatement_in_statement5847 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_WHILE_in_statement5857 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_parExpression_in_statement5859 = new BitSet(new long[]{0x0710006A06070C00L,0xDEC0C8141407228CL,0x000000000000051AL});
    public static final BitSet FOLLOW_statement_in_statement5861 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DO_in_statement5871 = new BitSet(new long[]{0x0710006A06070C00L,0xDEC0C8141407228CL,0x000000000000051AL});
    public static final BitSet FOLLOW_statement_in_statement5873 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000400L});
    public static final BitSet FOLLOW_WHILE_in_statement5875 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_parExpression_in_statement5877 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5879 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_trystatement_in_statement5889 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SWITCH_in_statement5899 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_parExpression_in_statement5901 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_LBRACE_in_statement5903 = new BitSet(new long[]{0x0000000400800000L,0x0000020000000000L});
    public static final BitSet FOLLOW_switchBlockStatementGroups_in_statement5905 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L});
    public static final BitSet FOLLOW_RBRACE_in_statement5907 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SYNCHRONIZED_in_statement5917 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_parExpression_in_statement5919 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_block_in_statement5921 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RETURN_in_statement5931 = new BitSet(new long[]{0x0310006006050800L,0x46C0C01414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_statement5934 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5939 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THROW_in_statement5949 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_statement5951 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5953 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BREAK_in_statement5963 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_statement5978 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement5995 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CONTINUE_in_statement6005 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_statement6020 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement6037 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_statement6047 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_statement6050 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_statement6065 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_statement6067 = new BitSet(new long[]{0x0710006A06070C00L,0xDEC0C8141407228CL,0x000000000000051AL});
    public static final BitSet FOLLOW_statement_in_statement6069 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_statement6079 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_switchBlockStatementGroup_in_switchBlockStatementGroups6101 = new BitSet(new long[]{0x0000000400800002L});
    public static final BitSet FOLLOW_switchLabel_in_switchBlockStatementGroup6130 = new BitSet(new long[]{0x0750106A0E070C12L,0xDEF0C8F41687238CL,0x000000000000071EL});
    public static final BitSet FOLLOW_blockStatement_in_switchBlockStatementGroup6141 = new BitSet(new long[]{0x0750106A0E070C12L,0xDEF0C8F41687238CL,0x000000000000071EL});
    public static final BitSet FOLLOW_CASE_in_switchLabel6172 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_switchLabel6174 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_switchLabel6176 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DEFAULT_in_switchLabel6186 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_switchLabel6188 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TRY_in_trystatement6208 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_block_in_trystatement6210 = new BitSet(new long[]{0x0080000001000000L});
    public static final BitSet FOLLOW_catches_in_trystatement6224 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_FINALLY_in_trystatement6226 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_block_in_trystatement6228 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catches_in_trystatement6242 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FINALLY_in_trystatement6256 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_block_in_trystatement6258 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TRY_in_trystatement6278 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_resourceSpecification_in_trystatement6280 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_block_in_trystatement6282 = new BitSet(new long[]{0x0080000001000002L});
    public static final BitSet FOLLOW_catches_in_trystatement6292 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_FINALLY_in_trystatement6294 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_block_in_trystatement6296 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catches_in_trystatement6310 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FINALLY_in_trystatement6324 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_block_in_trystatement6326 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_resourceSpecification6359 = new BitSet(new long[]{0x0140002002050000L,0x0000800000810084L});
    public static final BitSet FOLLOW_resource_in_resourceSpecification6361 = new BitSet(new long[]{0x0000000000000000L,0x0000600000000000L});
    public static final BitSet FOLLOW_SEMI_in_resourceSpecification6364 = new BitSet(new long[]{0x0140002002050000L,0x0000800000810084L});
    public static final BitSet FOLLOW_resource_in_resourceSpecification6366 = new BitSet(new long[]{0x0000000000000000L,0x0000600000000000L});
    public static final BitSet FOLLOW_SEMI_in_resourceSpecification6370 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_resourceSpecification6373 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableModifiers_in_resource6391 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_resource6398 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_resource6402 = new BitSet(new long[]{0x0000800000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_resource6405 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_resource6407 = new BitSet(new long[]{0x0000800000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_EQ_in_resource6412 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_resource6415 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catchClause_in_catches6435 = new BitSet(new long[]{0x0000000001000002L});
    public static final BitSet FOLLOW_catchClause_in_catches6446 = new BitSet(new long[]{0x0000000001000002L});
    public static final BitSet FOLLOW_CATCH_in_catchClause6477 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_LPAREN_in_catchClause6479 = new BitSet(new long[]{0x0140002002050000L,0x0000800000810084L});
    public static final BitSet FOLLOW_formalParameter_in_catchClause6481 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_catchClause6491 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_block_in_catchClause6493 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableModifiers_in_formalParameter6514 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_formalParameter6516 = new BitSet(new long[]{0x0000000000002000L,0x0000000000000004L});
    public static final BitSet FOLLOW_BAR_in_formalParameter6519 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_formalParameter6521 = new BitSet(new long[]{0x0000000000002000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_formalParameter6525 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_formalParameter6536 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_formalParameter6538 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_FOR_in_forstatement6587 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_LPAREN_in_forstatement6589 = new BitSet(new long[]{0x0140002002050000L,0x0000800000810084L});
    public static final BitSet FOLLOW_variableModifiers_in_forstatement6591 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_forstatement6593 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_forstatement6595 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_forstatement6597 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_forstatement6608 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_forstatement6610 = new BitSet(new long[]{0x0710006A06070C00L,0xDEC0C8141407228CL,0x000000000000051AL});
    public static final BitSet FOLLOW_statement_in_forstatement6612 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FOR_in_forstatement6644 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_LPAREN_in_forstatement6646 = new BitSet(new long[]{0x0350006006050800L,0x46C0C01414870284L,0x000000000000010AL});
    public static final BitSet FOLLOW_forInit_in_forstatement6666 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_forstatement6687 = new BitSet(new long[]{0x0310006006050800L,0x46C0C01414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_forstatement6707 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_forstatement6728 = new BitSet(new long[]{0x0310006006050800L,0x46C0A01414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expressionList_in_forstatement6748 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_forstatement6769 = new BitSet(new long[]{0x0710006A06070C00L,0xDEC0C8141407228CL,0x000000000000051AL});
    public static final BitSet FOLLOW_statement_in_forstatement6771 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localVariableDeclaration_in_forInit6791 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionList_in_forInit6801 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_parExpression6821 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_parExpression6823 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_parExpression6825 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_expressionList6845 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_COMMA_in_expressionList6856 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_expressionList6858 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_conditionalExpression_in_expression6890 = new BitSet(new long[]{0x4000800000408082L,0x010A000A00080000L});
    public static final BitSet FOLLOW_assignmentOperator_in_expression6901 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_expression6903 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_EQ_in_assignmentOperator6935 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PLUSEQ_in_assignmentOperator6945 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUBEQ_in_assignmentOperator6955 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_STAREQ_in_assignmentOperator6965 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SLASHEQ_in_assignmentOperator6975 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_AMPEQ_in_assignmentOperator6985 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BAREQ_in_assignmentOperator6995 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_CARETEQ_in_assignmentOperator7005 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PERCENTEQ_in_assignmentOperator7015 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LT_in_assignmentOperator7026 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
    public static final BitSet FOLLOW_LT_in_assignmentOperator7028 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_EQ_in_assignmentOperator7030 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator7041 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator7043 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator7045 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_EQ_in_assignmentOperator7047 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator7058 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_GT_in_assignmentOperator7060 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_EQ_in_assignmentOperator7062 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalOrExpression_in_conditionalExpression7083 = new BitSet(new long[]{0x0000000000000002L,0x0000010000000000L});
    public static final BitSet FOLLOW_QUES_in_conditionalExpression7094 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_conditionalExpression7096 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_conditionalExpression7098 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_conditionalExpression_in_conditionalExpression7100 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression7131 = new BitSet(new long[]{0x0000000000004002L});
    public static final BitSet FOLLOW_BARBAR_in_conditionalOrExpression7142 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression7144 = new BitSet(new long[]{0x0000000000004002L});
    public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression7175 = new BitSet(new long[]{0x0000000000000042L});
    public static final BitSet FOLLOW_AMPAMP_in_conditionalAndExpression7186 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_inclusiveOrExpression_in_conditionalAndExpression7188 = new BitSet(new long[]{0x0000000000000042L});
    public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression7219 = new BitSet(new long[]{0x0000000000002002L});
    public static final BitSet FOLLOW_BAR_in_inclusiveOrExpression7230 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_exclusiveOrExpression_in_inclusiveOrExpression7232 = new BitSet(new long[]{0x0000000000002002L});
    public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression7263 = new BitSet(new long[]{0x0000000000200002L});
    public static final BitSet FOLLOW_CARET_in_exclusiveOrExpression7274 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_andExpression_in_exclusiveOrExpression7276 = new BitSet(new long[]{0x0000000000200002L});
    public static final BitSet FOLLOW_equalityExpression_in_andExpression7307 = new BitSet(new long[]{0x0000000000000022L});
    public static final BitSet FOLLOW_AMP_in_andExpression7318 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_equalityExpression_in_andExpression7320 = new BitSet(new long[]{0x0000000000000022L});
    public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression7351 = new BitSet(new long[]{0x0001000000001002L});
    public static final BitSet FOLLOW_set_in_equalityExpression7378 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_instanceOfExpression_in_equalityExpression7428 = new BitSet(new long[]{0x0001000000001002L});
    public static final BitSet FOLLOW_relationalExpression_in_instanceOfExpression7459 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000040L});
    public static final BitSet FOLLOW_INSTANCEOF_in_instanceOfExpression7470 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_instanceOfExpression7472 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpression7503 = new BitSet(new long[]{0x4000000000000002L,0x0000000000080000L});
    public static final BitSet FOLLOW_relationalOp_in_relationalExpression7514 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpression7516 = new BitSet(new long[]{0x4000000000000002L,0x0000000000080000L});
    public static final BitSet FOLLOW_LT_in_relationalOp7548 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_EQ_in_relationalOp7550 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_relationalOp7561 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_EQ_in_relationalOp7563 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LT_in_relationalOp7573 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_relationalOp7583 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_additiveExpression_in_shiftExpression7603 = new BitSet(new long[]{0x4000000000000002L,0x0000000000080000L});
    public static final BitSet FOLLOW_shiftOp_in_shiftExpression7614 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_additiveExpression_in_shiftExpression7616 = new BitSet(new long[]{0x4000000000000002L,0x0000000000080000L});
    public static final BitSet FOLLOW_LT_in_shiftOp7649 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
    public static final BitSet FOLLOW_LT_in_shiftOp7651 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_shiftOp7662 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_GT_in_shiftOp7664 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_GT_in_shiftOp7666 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_GT_in_shiftOp7677 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_GT_in_shiftOp7679 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression7700 = new BitSet(new long[]{0x0000000000000002L,0x0080000400000000L});
    public static final BitSet FOLLOW_set_in_additiveExpression7727 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression7777 = new BitSet(new long[]{0x0000000000000002L,0x0080000400000000L});
    public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression7815 = new BitSet(new long[]{0x0000000000000002L,0x0005000100000000L});
    public static final BitSet FOLLOW_set_in_multiplicativeExpression7842 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression7910 = new BitSet(new long[]{0x0000000000000002L,0x0005000100000000L});
    public static final BitSet FOLLOW_PLUS_in_unaryExpression7943 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression7946 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUB_in_unaryExpression7956 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression7958 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_PLUSPLUS_in_unaryExpression7968 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression7970 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUBSUB_in_unaryExpression7980 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression7982 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_unaryExpressionNotPlusMinus_in_unaryExpression7992 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_TILDE_in_unaryExpressionNotPlusMinus8012 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus8014 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_BANG_in_unaryExpressionNotPlusMinus8024 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpressionNotPlusMinus8026 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_castExpression_in_unaryExpressionNotPlusMinus8036 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primary_in_unaryExpressionNotPlusMinus8046 = new BitSet(new long[]{0x0000001000000002L,0x0200001000004000L});
    public static final BitSet FOLLOW_selector_in_unaryExpressionNotPlusMinus8057 = new BitSet(new long[]{0x0000001000000002L,0x0200001000004000L});
    public static final BitSet FOLLOW_LPAREN_in_castExpression8127 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010080L});
    public static final BitSet FOLLOW_primitiveType_in_castExpression8129 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_castExpression8131 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_unaryExpression_in_castExpression8133 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_castExpression8143 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_castExpression8145 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_castExpression8147 = new BitSet(new long[]{0x0310006006050800L,0x4440800014070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_unaryExpressionNotPlusMinus_in_castExpression8149 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_parExpression_in_primary8171 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_THIS_in_primary8193 = new BitSet(new long[]{0x0000001000000002L,0x0000000000044000L});
    public static final BitSet FOLLOW_DOT_in_primary8204 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_primary8206 = new BitSet(new long[]{0x0000001000000002L,0x0000000000044000L});
    public static final BitSet FOLLOW_identifierSuffix_in_primary8228 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_primary8249 = new BitSet(new long[]{0x0000001000000002L,0x0000000000044000L});
    public static final BitSet FOLLOW_DOT_in_primary8260 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_primary8262 = new BitSet(new long[]{0x0000001000000002L,0x0000000000044000L});
    public static final BitSet FOLLOW_identifierSuffix_in_primary8284 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SUPER_in_primary8305 = new BitSet(new long[]{0x0000001000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_superSuffix_in_primary8315 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literal_in_primary8325 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_creator_in_primary8335 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primitiveType_in_primary8345 = new BitSet(new long[]{0x0000001000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_primary8356 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_primary8358 = new BitSet(new long[]{0x0000001000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_DOT_in_primary8379 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_CLASS_in_primary8381 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_VOID_in_primary8391 = new BitSet(new long[]{0x0000001000000000L});
    public static final BitSet FOLLOW_DOT_in_primary8393 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_CLASS_in_primary8395 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arguments_in_superSuffix8421 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_superSuffix8431 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080004L});
    public static final BitSet FOLLOW_typeArguments_in_superSuffix8434 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_superSuffix8455 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
    public static final BitSet FOLLOW_arguments_in_superSuffix8466 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACKET_in_identifierSuffix8499 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_identifierSuffix8501 = new BitSet(new long[]{0x0000001000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_DOT_in_identifierSuffix8522 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_CLASS_in_identifierSuffix8524 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACKET_in_identifierSuffix8535 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_identifierSuffix8537 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_identifierSuffix8539 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_arguments_in_identifierSuffix8560 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_identifierSuffix8570 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_CLASS_in_identifierSuffix8572 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_identifierSuffix8582 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_identifierSuffix8584 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_identifierSuffix8586 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_arguments_in_identifierSuffix8588 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_identifierSuffix8598 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L});
    public static final BitSet FOLLOW_THIS_in_identifierSuffix8600 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_identifierSuffix8610 = new BitSet(new long[]{0x0000000000000000L,0x0400000000000000L});
    public static final BitSet FOLLOW_SUPER_in_identifierSuffix8612 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_arguments_in_identifierSuffix8614 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_innerCreator_in_identifierSuffix8624 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_selector8646 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_selector8648 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
    public static final BitSet FOLLOW_arguments_in_selector8659 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_selector8680 = new BitSet(new long[]{0x0000000000000000L,0x4000000000000000L});
    public static final BitSet FOLLOW_THIS_in_selector8682 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_selector8692 = new BitSet(new long[]{0x0000000000000000L,0x0400000000000000L});
    public static final BitSet FOLLOW_SUPER_in_selector8694 = new BitSet(new long[]{0x0000001000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_superSuffix_in_selector8704 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_innerCreator_in_selector8714 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACKET_in_selector8724 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_selector8726 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_selector8728 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_creator8748 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_creator8750 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_classOrInterfaceType_in_creator8752 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_classCreatorRest_in_creator8754 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_creator8764 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_classOrInterfaceType_in_creator8766 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_classCreatorRest_in_creator8768 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayCreator_in_creator8778 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_arrayCreator8798 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_createdName_in_arrayCreator8800 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_arrayCreator8810 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_arrayCreator8812 = new BitSet(new long[]{0x0000000000000000L,0x0000000000006000L});
    public static final BitSet FOLLOW_LBRACKET_in_arrayCreator8823 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_arrayCreator8825 = new BitSet(new long[]{0x0000000000000000L,0x0000000000006000L});
    public static final BitSet FOLLOW_arrayInitializer_in_arrayCreator8846 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_arrayCreator8857 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_createdName_in_arrayCreator8859 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_arrayCreator8869 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_arrayCreator8871 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_arrayCreator8881 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_arrayCreator8895 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_arrayCreator8897 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_arrayCreator8911 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_arrayCreator8933 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_arrayCreator8935 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
    public static final BitSet FOLLOW_arrayInitializer_in_variableInitializer8966 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_variableInitializer8976 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACE_in_arrayInitializer8996 = new BitSet(new long[]{0x0310006046050800L,0x46C0821414072284L,0x000000000000010AL});
    public static final BitSet FOLLOW_variableInitializer_in_arrayInitializer9012 = new BitSet(new long[]{0x0000000040000000L,0x0000020000000000L});
    public static final BitSet FOLLOW_COMMA_in_arrayInitializer9031 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414072284L,0x000000000000010AL});
    public static final BitSet FOLLOW_variableInitializer_in_arrayInitializer9033 = new BitSet(new long[]{0x0000000040000000L,0x0000020000000000L});
    public static final BitSet FOLLOW_COMMA_in_arrayInitializer9083 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L});
    public static final BitSet FOLLOW_RBRACE_in_arrayInitializer9096 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classOrInterfaceType_in_createdName9130 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primitiveType_in_createdName9140 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_innerCreator9161 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L});
    public static final BitSet FOLLOW_NEW_in_innerCreator9163 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080004L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_innerCreator9174 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_innerCreator9195 = new BitSet(new long[]{0x0000000000000000L,0x00000000000C0000L});
    public static final BitSet FOLLOW_typeArguments_in_innerCreator9206 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_classCreatorRest_in_innerCreator9227 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arguments_in_classCreatorRest9248 = new BitSet(new long[]{0x0000000000000002L,0x0000000000002000L});
    public static final BitSet FOLLOW_classBody_in_classCreatorRest9259 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LT_in_nonWildcardTypeArguments9291 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_typeList_in_nonWildcardTypeArguments9293 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_GT_in_nonWildcardTypeArguments9303 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_arguments9323 = new BitSet(new long[]{0x0310006006050800L,0x46C0A01414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expressionList_in_arguments9326 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_arguments9339 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_classHeader9463 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_CLASS_in_classHeader9465 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_classHeader9467 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_enumHeader9487 = new BitSet(new long[]{0x0000100000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_set_in_enumHeader9489 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_enumHeader9495 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_interfaceHeader9515 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_INTERFACE_in_interfaceHeader9517 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_interfaceHeader9519 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_annotationHeader9539 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});
    public static final BitSet FOLLOW_MONKEYS_AT_in_annotationHeader9541 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_INTERFACE_in_annotationHeader9543 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_annotationHeader9545 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_typeHeader9565 = new BitSet(new long[]{0x0000100008000000L,0x0000000000800100L});
    public static final BitSet FOLLOW_CLASS_in_typeHeader9568 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_ENUM_in_typeHeader9570 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_MONKEYS_AT_in_typeHeader9573 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_INTERFACE_in_typeHeader9577 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_typeHeader9581 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_methodHeader9601 = new BitSet(new long[]{0x0100002002050000L,0x0000800000090084L,0x0000000000000100L});
    public static final BitSet FOLLOW_typeParameters_in_methodHeader9603 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L,0x0000000000000100L});
    public static final BitSet FOLLOW_type_in_methodHeader9607 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_VOID_in_methodHeader9609 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_methodHeader9613 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_LPAREN_in_methodHeader9615 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_fieldHeader9635 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_fieldHeader9637 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_fieldHeader9639 = new BitSet(new long[]{0x0000800040000000L,0x0000400000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_fieldHeader9642 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_fieldHeader9643 = new BitSet(new long[]{0x0000800040000000L,0x0000400000004000L});
    public static final BitSet FOLLOW_set_in_fieldHeader9647 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableModifiers_in_localVariableHeader9673 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_localVariableHeader9675 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_localVariableHeader9677 = new BitSet(new long[]{0x0000800040000000L,0x0000400000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_localVariableHeader9680 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_localVariableHeader9681 = new BitSet(new long[]{0x0000800040000000L,0x0000400000004000L});
    public static final BitSet FOLLOW_set_in_localVariableHeader9685 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotations_in_synpred2_JavaTree169 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L});
    public static final BitSet FOLLOW_packageDeclaration_in_synpred2_JavaTree173 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_synpred12_JavaTree513 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalClassDeclaration_in_synpred27_JavaTree749 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalInterfaceDeclaration_in_synpred43_JavaTree1744 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_fieldDeclaration_in_synpred52_JavaTree2224 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_methodDeclaration_in_synpred53_JavaTree2235 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_synpred54_JavaTree2246 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_explicitConstructorInvocation_in_synpred57_JavaTree2383 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_synpred59_JavaTree2295 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080004L});
    public static final BitSet FOLLOW_typeParameters_in_synpred59_JavaTree2306 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred59_JavaTree2327 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_formalParameters_in_synpred59_JavaTree2337 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L,0x0000000000000001L});
    public static final BitSet FOLLOW_THROWS_in_synpred59_JavaTree2348 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_qualifiedNameList_in_synpred59_JavaTree2350 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_LBRACE_in_synpred59_JavaTree2371 = new BitSet(new long[]{0x0750106A0E070C10L,0xDEF0CAF4168F238CL,0x000000000000071EL});
    public static final BitSet FOLLOW_explicitConstructorInvocation_in_synpred59_JavaTree2383 = new BitSet(new long[]{0x0750106A0E070C10L,0xDEF0CAF41687238CL,0x000000000000071EL});
    public static final BitSet FOLLOW_blockStatement_in_synpred59_JavaTree2405 = new BitSet(new long[]{0x0750106A0E070C10L,0xDEF0CAF41687238CL,0x000000000000071EL});
    public static final BitSet FOLLOW_RBRACE_in_synpred59_JavaTree2426 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_synpred64_JavaTree2483 = new BitSet(new long[]{0x0100002002050000L,0x0000800000090084L});
    public static final BitSet FOLLOW_typeParameters_in_synpred64_JavaTree2494 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_synpred64_JavaTree2515 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred64_JavaTree2525 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_formalParameters_in_synpred64_JavaTree2535 = new BitSet(new long[]{0x0000000000000000L,0x0000400000006000L,0x0000000000000001L});
    public static final BitSet FOLLOW_LBRACKET_in_synpred64_JavaTree2546 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_synpred64_JavaTree2548 = new BitSet(new long[]{0x0000000000000000L,0x0000400000006000L,0x0000000000000001L});
    public static final BitSet FOLLOW_THROWS_in_synpred64_JavaTree2570 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_qualifiedNameList_in_synpred64_JavaTree2572 = new BitSet(new long[]{0x0000000000000000L,0x0000400000002000L});
    public static final BitSet FOLLOW_block_in_synpred64_JavaTree2627 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_SEMI_in_synpred64_JavaTree2641 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFieldDeclaration_in_synpred72_JavaTree3181 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceMethodDeclaration_in_synpred73_JavaTree3191 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceDeclaration_in_synpred74_JavaTree3201 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_synpred75_JavaTree3211 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_modifiers_in_synpred79_JavaTree3241 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L,0x0000000000000100L});
    public static final BitSet FOLLOW_typeParameters_in_synpred79_JavaTree3252 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_VOID_in_synpred79_JavaTree3273 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred79_JavaTree3283 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_formalParameters_in_synpred79_JavaTree3293 = new BitSet(new long[]{0x0000000000000000L,0x0000400000004000L,0x0000000000000001L});
    public static final BitSet FOLLOW_LBRACKET_in_synpred79_JavaTree3304 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_synpred79_JavaTree3306 = new BitSet(new long[]{0x0000000000000000L,0x0000400000004000L,0x0000000000000001L});
    public static final BitSet FOLLOW_THROWS_in_synpred79_JavaTree3328 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_qualifiedNameList_in_synpred79_JavaTree3330 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred79_JavaTree3343 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ellipsisParameterDecl_in_synpred105_JavaTree4342 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalParameterDecl_in_synpred107_JavaTree4360 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_COMMA_in_synpred107_JavaTree4371 = new BitSet(new long[]{0x0140002002050000L,0x0000800000810084L});
    public static final BitSet FOLLOW_normalParameterDecl_in_synpred107_JavaTree4373 = new BitSet(new long[]{0x0000000040000002L});
    public static final BitSet FOLLOW_normalParameterDecl_in_synpred108_JavaTree4426 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_COMMA_in_synpred108_JavaTree4436 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_synpred112_JavaTree4636 = new BitSet(new long[]{0x0000000000000000L,0x4400000000000000L});
    public static final BitSet FOLLOW_set_in_synpred112_JavaTree4662 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_arguments_in_synpred112_JavaTree4694 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred112_JavaTree4696 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationMethodDeclaration_in_synpred126_JavaTree5366 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceFieldDeclaration_in_synpred127_JavaTree5376 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalClassDeclaration_in_synpred128_JavaTree5386 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_normalInterfaceDeclaration_in_synpred129_JavaTree5396 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_enumDeclaration_in_synpred130_JavaTree5406 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_annotationTypeDeclaration_in_synpred131_JavaTree5416 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localVariableDeclarationStatement_in_synpred134_JavaTree5592 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classOrInterfaceDeclaration_in_synpred135_JavaTree5602 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSERT_in_synpred139_JavaTree5743 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_synpred139_JavaTree5763 = new BitSet(new long[]{0x0000000020000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_COLON_in_synpred139_JavaTree5766 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_synpred139_JavaTree5768 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred139_JavaTree5772 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ASSERT_in_synpred141_JavaTree5782 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_synpred141_JavaTree5785 = new BitSet(new long[]{0x0000000020000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_COLON_in_synpred141_JavaTree5788 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_synpred141_JavaTree5790 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred141_JavaTree5794 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ELSE_in_synpred142_JavaTree5823 = new BitSet(new long[]{0x0710006A06070C00L,0xDEC0C8141407228CL,0x000000000000051AL});
    public static final BitSet FOLLOW_statement_in_synpred142_JavaTree5825 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_synpred157_JavaTree6047 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L});
    public static final BitSet FOLLOW_SEMI_in_synpred157_JavaTree6050 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred158_JavaTree6065 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_synpred158_JavaTree6067 = new BitSet(new long[]{0x0710006A06070C00L,0xDEC0C8141407228CL,0x000000000000051AL});
    public static final BitSet FOLLOW_statement_in_synpred158_JavaTree6069 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catches_in_synpred162_JavaTree6224 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_FINALLY_in_synpred162_JavaTree6226 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_block_in_synpred162_JavaTree6228 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catches_in_synpred163_JavaTree6242 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catches_in_synpred165_JavaTree6292 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_FINALLY_in_synpred165_JavaTree6294 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_block_in_synpred165_JavaTree6296 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_catches_in_synpred166_JavaTree6310 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_FOR_in_synpred174_JavaTree6587 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_LPAREN_in_synpred174_JavaTree6589 = new BitSet(new long[]{0x0140002002050000L,0x0000800000810084L});
    public static final BitSet FOLLOW_variableModifiers_in_synpred174_JavaTree6591 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_type_in_synpred174_JavaTree6593 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred174_JavaTree6595 = new BitSet(new long[]{0x0000000020000000L});
    public static final BitSet FOLLOW_COLON_in_synpred174_JavaTree6597 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_synpred174_JavaTree6608 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_synpred174_JavaTree6610 = new BitSet(new long[]{0x0710006A06070C00L,0xDEC0C8141407228CL,0x000000000000051AL});
    public static final BitSet FOLLOW_statement_in_synpred174_JavaTree6612 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_localVariableDeclaration_in_synpred178_JavaTree6791 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_castExpression_in_synpred219_JavaTree8036 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LPAREN_in_synpred223_JavaTree8127 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010080L});
    public static final BitSet FOLLOW_primitiveType_in_synpred223_JavaTree8129 = new BitSet(new long[]{0x0000000000000000L,0x0000200000000000L});
    public static final BitSet FOLLOW_RPAREN_in_synpred223_JavaTree8131 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_unaryExpression_in_synpred223_JavaTree8133 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_synpred225_JavaTree8204 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred225_JavaTree8206 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierSuffix_in_synpred226_JavaTree8228 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_DOT_in_synpred228_JavaTree8260 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_IDENTIFIER_in_synpred228_JavaTree8262 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_identifierSuffix_in_synpred229_JavaTree8284 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACKET_in_synpred241_JavaTree8535 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_synpred241_JavaTree8537 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_synpred241_JavaTree8539 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_synpred253_JavaTree8748 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
    public static final BitSet FOLLOW_nonWildcardTypeArguments_in_synpred253_JavaTree8750 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_classOrInterfaceType_in_synpred253_JavaTree8752 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_classCreatorRest_in_synpred253_JavaTree8754 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_synpred254_JavaTree8764 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_classOrInterfaceType_in_synpred254_JavaTree8766 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
    public static final BitSet FOLLOW_classCreatorRest_in_synpred254_JavaTree8768 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_NEW_in_synpred256_JavaTree8798 = new BitSet(new long[]{0x0100002002050000L,0x0000800000010084L});
    public static final BitSet FOLLOW_createdName_in_synpred256_JavaTree8800 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_LBRACKET_in_synpred256_JavaTree8810 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_synpred256_JavaTree8812 = new BitSet(new long[]{0x0000000000000000L,0x0000000000006000L});
    public static final BitSet FOLLOW_LBRACKET_in_synpred256_JavaTree8823 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_synpred256_JavaTree8825 = new BitSet(new long[]{0x0000000000000000L,0x0000000000006000L});
    public static final BitSet FOLLOW_arrayInitializer_in_synpred256_JavaTree8846 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LBRACKET_in_synpred257_JavaTree8895 = new BitSet(new long[]{0x0310006006050800L,0x46C0801414070284L,0x000000000000010AL});
    public static final BitSet FOLLOW_expression_in_synpred257_JavaTree8897 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L});
    public static final BitSet FOLLOW_RBRACKET_in_synpred257_JavaTree8911 = new BitSet(new long[]{0x0000000000000002L});

}